add #1.2.3p4 style paragraph links
authornsz <nsz@port70.net>
Wed, 5 Sep 2012 08:45:39 +0000 (10:45 +0200)
committernsz <nsz@port70.net>
Wed, 5 Sep 2012 08:45:39 +0000 (10:45 +0200)
ann2html.sh
n1256.html
n1570.html

index 5a93b35..f7edb9b 100755 (executable)
@@ -164,7 +164,7 @@ seencontents && !seenfore && /^[^@]/ {
 }
 
 /^@para/ {
-       ss[sid] = ss[sid] "<p><!--para " $2 " -->\n"
+       ss[sid] = ss[sid] sprintf("<p><a name=\"%sp%s\" href=\"#%sp%s\"><small>%s</small></a>\n", sect, $2, sect, $2, $2)
        next
 }
 
index a07b492..c628b68 100644 (file)
@@ -380,7 +380,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h2><a name="Foreword" href="#Foreword">Foreword</a></h2>
-<p><!--para 1 -->
+<p><a name="Forewordp1" href="#Forewordp1"><small>1</small></a>
  ISO (the International Organization for Standardization) and IEC (the International
  Electrotechnical Commission) form the specialized system for worldwide
  standardization. National bodies that are member of ISO or IEC participate in the
@@ -389,15 +389,15 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  technical committees collaborate in fields of mutual interest. Other international
  organizations, governmental and non-governmental, in liaison with ISO and IEC, also
  take part in the work.
-<p><!--para 2 -->
+<p><a name="Forewordp2" href="#Forewordp2"><small>2</small></a>
  International Standards are drafted in accordance with the rules given in the ISO/IEC
  Directives, Part 3.
-<p><!--para 3 -->
+<p><a name="Forewordp3" href="#Forewordp3"><small>3</small></a>
  In the field of information technology, ISO and IEC have established a joint technical
  committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
  committee are circulated to national bodies for voting. Publication as an International
  Standard requires approval by at least 75% of the national bodies casting a vote.
-<p><!--para 4 -->
+<p><a name="Forewordp4" href="#Forewordp4"><small>4</small></a>
  International Standard ISO/IEC 9899 was prepared by Joint Technical Committee
  ISO/IEC JTC 1, Information technology, Subcommittee SC 22, Programming languages,
  their environments and system software interfaces. The Working Group responsible for
@@ -405,7 +405,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  http://www.open-std.org/JTC1/SC22/WG14/                        containing      additional
  information relevant to this standard such as a Rationale for many of the decisions made
  during its preparation and a log of Defect Reports and Responses.
-<p><!--para 5 -->
+<p><a name="Forewordp5" href="#Forewordp5"><small>5</small></a>
  This second edition cancels and replaces the first edition, ISO/IEC 9899:1990, as
  amended and corrected by ISO/IEC 9899/COR1:1994, ISO/IEC 9899/AMD1:1995, and
  ISO/IEC 9899/COR2:1996. Major changes from the previous edition include:
@@ -471,7 +471,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <li>  return without expression not permitted in function that returns a value (and vice
  versa)
 </ul>
-<p><!--para 6 -->
+<p><a name="Forewordp6" href="#Forewordp6"><small>6</small></a>
  Annexes D and F form a normative part of this standard; annexes A, B, C, E, G, H, I, J,
  the bibliography, and the index are for information only. In accordance with Part 3 of the
  ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples are
@@ -480,17 +480,17 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h2><a name="Introduction" href="#Introduction">Introduction</a></h2>
-<p><!--para 1 -->
+<p><a name="Introductionp1" href="#Introductionp1"><small>1</small></a>
  With the introduction of new devices and extended character sets, new features may be
  added to this International Standard. Subclauses in the language and library clauses warn
  implementors and programmers of usages which, though valid in themselves, may
  conflict with future additions.
-<p><!--para 2 -->
+<p><a name="Introductionp2" href="#Introductionp2"><small>2</small></a>
  Certain features are obsolescent, which means that they may be considered for
  withdrawal in future revisions of this International Standard. They are retained because
  of their widespread use, but their use in new implementations (for implementation
  features) or new programs (for language [<a href="#6.11">6.11</a>] or library features [<a href="#7.26">7.26</a>]) is discouraged.
-<p><!--para 3 -->
+<p><a name="Introductionp3" href="#Introductionp3"><small>3</small></a>
  This International Standard is divided into four major subdivisions:
 <ul>
 <li>  preliminary elements (clauses 1-4);
@@ -498,7 +498,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <li>  the language syntax, constraints, and semantics (clause 6);
 <li>  the library facilities (clause 7).
 </ul>
-<p><!--para 4 -->
+<p><a name="Introductionp4" href="#Introductionp4"><small>4</small></a>
  Examples are provided to illustrate possible forms of the constructions described.
  Footnotes are provided to emphasize consequences of the rules described in that
  subclause or elsewhere in this International Standard. References are used to refer to
@@ -506,9 +506,9 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  implementors. Annexes provide additional information and summarize the information
  contained in this International Standard. A bibliography lists documents that were
  referred to during the preparation of the standard.
-<p><!--para 5 -->
+<p><a name="Introductionp5" href="#Introductionp5"><small>5</small></a>
  The language clause (clause 6) is derived from ''The C Reference Manual''.
-<p><!--para 6 -->
+<p><a name="Introductionp6" href="#Introductionp6"><small>6</small></a>
  The library clause (clause 7) is based on the 1984 /usr/group Standard.
 <!--page 13 -->
 
@@ -521,7 +521,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h2><a name="1" href="#1">1. Scope</a></h2>
-<p><!--para 1 -->
+<p><a name="1p1" href="#1p1"><small>1</small></a>
  This International Standard specifies the form and establishes the interpretation of
  programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
 <ul>
@@ -532,7 +532,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <li>  the representation of output data produced by C programs;
 <li>  the restrictions and limits imposed by a conforming implementation of C.
 </ul>
-<p><!--para 2 -->
+<p><a name="1p2" href="#1p2"><small>2</small></a>
  This International Standard does not specify
 <ul>
 <li>  the mechanism by which C programs are transformed for use by a data-processing
@@ -559,7 +559,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h2><a name="2" href="#2">2. Normative references</a></h2>
-<p><!--para 1 -->
+<p><a name="2p1" href="#2p1"><small>1</small></a>
  The following normative documents contain provisions which, through reference in this
  text, constitute provisions of this International Standard. For dated references,
  subsequent amendments to, or revisions of, any of these publications do not apply.
@@ -568,31 +568,31 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  documents indicated below. For undated references, the latest edition of the normative
  document referred to applies. Members of ISO and IEC maintain registers of currently
  valid International Standards.
-<p><!--para 2 -->
+<p><a name="2p2" href="#2p2"><small>2</small></a>
  ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and symbols for
  use in the physical sciences and technology.
-<p><!--para 3 -->
+<p><a name="2p3" href="#2p3"><small>3</small></a>
  ISO/IEC 646, Information technology -- ISO 7-bit coded character set for information
  interchange.
-<p><!--para 4 -->
+<p><a name="2p4" href="#2p4"><small>4</small></a>
  ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1: Fundamental
  terms.
-<p><!--para 5 -->
+<p><a name="2p5" href="#2p5"><small>5</small></a>
  ISO 4217, Codes for the representation of currencies and funds.
-<p><!--para 6 -->
+<p><a name="2p6" href="#2p6"><small>6</small></a>
  ISO 8601, Data elements and interchange formats -- Information interchange --
  Representation of dates and times.
-<p><!--para 7 -->
+<p><a name="2p7" href="#2p7"><small>7</small></a>
  ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
  Character Set (UCS).
-<p><!--para 8 -->
+<p><a name="2p8" href="#2p8"><small>8</small></a>
  IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously
  designated IEC 559:1989).
 <!--page 15 -->
 
 <p><small><a href="#Contents">Contents</a></small>
 <h2><a name="3" href="#3">3. Terms, definitions, and symbols</a></h2>
-<p><!--para 1 -->
+<p><a name="3p1" href="#3p1"><small>1</small></a>
  For the purposes of this International Standard, the following definitions apply. Other
  terms are defined where they appear in italic type or on the left side of a syntax rule.
  Terms explicitly defined in this International Standard are not to be presumed to refer
@@ -602,29 +602,29 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.1" href="#3.1">3.1</a></h3>
-<p><!--para 1 -->
+<p><a name="3.1p1" href="#3.1p1"><small>1</small></a>
 <b> access</b><br>
  &lt;execution-time action&gt; to read or modify the value of an object
-<p><!--para 2 -->
+<p><a name="3.1p2" href="#3.1p2"><small>2</small></a>
  NOTE 1   Where only one of these two actions is meant, ''read'' or ''modify'' is used.
  
-<p><!--para 3 -->
+<p><a name="3.1p3" href="#3.1p3"><small>3</small></a>
  NOTE 2   "Modify'' includes the case where the new value being stored is the same as the previous value.
  
-<p><!--para 4 -->
+<p><a name="3.1p4" href="#3.1p4"><small>4</small></a>
  NOTE 3   Expressions that are not evaluated do not access objects.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.2" href="#3.2">3.2</a></h3>
-<p><!--para 1 -->
+<p><a name="3.2p1" href="#3.2p1"><small>1</small></a>
 <b> alignment</b><br>
  requirement that objects of a particular type be located on storage boundaries with
  addresses that are particular multiples of a byte address
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.3" href="#3.3">3.3</a></h3>
-<p><!--para 1 -->
+<p><a name="3.3p1" href="#3.3p1"><small>1</small></a>
 <b> argument</b><br>
  actual argument<br>
  actual parameter (deprecated)<br>
@@ -634,80 +634,80 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.4" href="#3.4">3.4</a></h3>
-<p><!--para 1 -->
+<p><a name="3.4p1" href="#3.4p1"><small>1</small></a>
 <b> behavior</b><br>
  external appearance or action
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.4.1" href="#3.4.1">3.4.1</a></h4>
-<p><!--para 1 -->
+<p><a name="3.4.1p1" href="#3.4.1p1"><small>1</small></a>
 <b> implementation-defined behavior</b><br>
  unspecified behavior where each implementation documents how the choice is made
-<p><!--para 2 -->
+<p><a name="3.4.1p2" href="#3.4.1p2"><small>2</small></a>
  EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
  when a signed integer is shifted right.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.4.2" href="#3.4.2">3.4.2</a></h4>
-<p><!--para 1 -->
+<p><a name="3.4.2p1" href="#3.4.2p1"><small>1</small></a>
 <b> locale-specific behavior</b><br>
  behavior that depends on local conventions of nationality, culture, and language that each
  implementation documents
 <!--page 16 -->
-<p><!--para 2 -->
+<p><a name="3.4.2p2" href="#3.4.2p2"><small>2</small></a>
  EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
  characters other than the 26 lowercase Latin letters.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.4.3" href="#3.4.3">3.4.3</a></h4>
-<p><!--para 1 -->
+<p><a name="3.4.3p1" href="#3.4.3p1"><small>1</small></a>
 <b> undefined behavior</b><br>
  behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
  for which this International Standard imposes no requirements
-<p><!--para 2 -->
+<p><a name="3.4.3p2" href="#3.4.3p2"><small>2</small></a>
  NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
  results, to behaving during translation or program execution in a documented manner characteristic of the
  environment (with or without the issuance of a diagnostic message), to terminating a translation or
  execution (with the issuance of a diagnostic message).
  
-<p><!--para 3 -->
+<p><a name="3.4.3p3" href="#3.4.3p3"><small>3</small></a>
  EXAMPLE        An example of undefined behavior is the behavior on integer overflow.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.4.4" href="#3.4.4">3.4.4</a></h4>
-<p><!--para 1 -->
+<p><a name="3.4.4p1" href="#3.4.4p1"><small>1</small></a>
 <b> unspecified behavior</b><br>
  use of an unspecified value, or other behavior where this International Standard provides
  two or more possibilities and imposes no further requirements on which is chosen in any
  instance
-<p><!--para 2 -->
+<p><a name="3.4.4p2" href="#3.4.4p2"><small>2</small></a>
  EXAMPLE        An example of unspecified behavior is the order in which the arguments to a function are
  evaluated.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.5" href="#3.5">3.5</a></h3>
-<p><!--para 1 -->
+<p><a name="3.5p1" href="#3.5p1"><small>1</small></a>
 <b> bit</b><br>
  unit of data storage in the execution environment large enough to hold an object that may
  have one of two values
-<p><!--para 2 -->
+<p><a name="3.5p2" href="#3.5p2"><small>2</small></a>
  NOTE     It need not be possible to express the address of each individual bit of an object.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.6" href="#3.6">3.6</a></h3>
-<p><!--para 1 -->
+<p><a name="3.6p1" href="#3.6p1"><small>1</small></a>
 <b> byte</b><br>
  addressable unit of data storage large enough to hold any member of the basic character
  set of the execution environment
-<p><!--para 2 -->
+<p><a name="3.6p2" href="#3.6p2"><small>2</small></a>
  NOTE 1 It is possible to express the address of each individual byte of an object uniquely.
  
-<p><!--para 3 -->
+<p><a name="3.6p3" href="#3.6p3"><small>3</small></a>
  NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
  defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
  bit.
@@ -715,14 +715,14 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.7" href="#3.7">3.7</a></h3>
-<p><!--para 1 -->
+<p><a name="3.7p1" href="#3.7p1"><small>1</small></a>
 <b> character</b><br>
  &lt;abstract&gt; member of a set of elements used for the organization, control, or
  representation of data
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.7.1" href="#3.7.1">3.7.1</a></h4>
-<p><!--para 1 -->
+<p><a name="3.7.1p1" href="#3.7.1p1"><small>1</small></a>
 <b> character</b><br>
  single-byte character
  &lt;C&gt; bit representation that fits in a byte
@@ -730,52 +730,52 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.7.2" href="#3.7.2">3.7.2</a></h4>
-<p><!--para 1 -->
+<p><a name="3.7.2p1" href="#3.7.2p1"><small>1</small></a>
 <b> multibyte character</b><br>
  sequence of one or more bytes representing a member of the extended character set of
  either the source or the execution environment
-<p><!--para 2 -->
+<p><a name="3.7.2p2" href="#3.7.2p2"><small>2</small></a>
  NOTE    The extended character set is a superset of the basic character set.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.7.3" href="#3.7.3">3.7.3</a></h4>
-<p><!--para 1 -->
+<p><a name="3.7.3p1" href="#3.7.3p1"><small>1</small></a>
 <b> wide character</b><br>
  bit representation that fits in an object of type wchar_t, capable of representing any
  character in the current locale
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.8" href="#3.8">3.8</a></h3>
-<p><!--para 1 -->
+<p><a name="3.8p1" href="#3.8p1"><small>1</small></a>
 <b> constraint</b><br>
  restriction, either syntactic or semantic, by which the exposition of language elements is
  to be interpreted
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.9" href="#3.9">3.9</a></h3>
-<p><!--para 1 -->
+<p><a name="3.9p1" href="#3.9p1"><small>1</small></a>
 <b> correctly rounded result</b><br>
  representation in the result format that is nearest in value, subject to the current rounding
  mode, to what the result would be given unlimited range and precision
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.10" href="#3.10">3.10</a></h3>
-<p><!--para 1 -->
+<p><a name="3.10p1" href="#3.10p1"><small>1</small></a>
 <b> diagnostic message</b><br>
  message belonging to an implementation-defined subset of the implementation's message
  output
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.11" href="#3.11">3.11</a></h3>
-<p><!--para 1 -->
+<p><a name="3.11p1" href="#3.11p1"><small>1</small></a>
 <b> forward reference</b><br>
  reference to a later subclause of this International Standard that contains additional
  information relevant to this subclause
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.12" href="#3.12">3.12</a></h3>
-<p><!--para 1 -->
+<p><a name="3.12p1" href="#3.12p1"><small>1</small></a>
 <b> implementation</b><br>
  particular set of software, running in a particular translation environment under particular
  control options, that performs translation of programs for, and supports execution of
@@ -783,24 +783,24 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.13" href="#3.13">3.13</a></h3>
-<p><!--para 1 -->
+<p><a name="3.13p1" href="#3.13p1"><small>1</small></a>
 <b> implementation limit</b><br>
  restriction imposed upon programs by the implementation
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.14" href="#3.14">3.14</a></h3>
-<p><!--para 1 -->
+<p><a name="3.14p1" href="#3.14p1"><small>1</small></a>
 <b> object</b><br>
  region of data storage in the execution environment, the contents of which can represent
  values
 <!--page 18 -->
-<p><!--para 2 -->
+<p><a name="3.14p2" href="#3.14p2"><small>2</small></a>
  NOTE     When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.15" href="#3.15">3.15</a></h3>
-<p><!--para 1 -->
+<p><a name="3.15p1" href="#3.15p1"><small>1</small></a>
 <b> parameter</b><br>
  formal parameter
  formal argument (deprecated)
@@ -810,82 +810,82 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.16" href="#3.16">3.16</a></h3>
-<p><!--para 1 -->
+<p><a name="3.16p1" href="#3.16p1"><small>1</small></a>
 <b> recommended practice</b><br>
  specification that is strongly recommended as being in keeping with the intent of the
  standard, but that may be impractical for some implementations
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.17" href="#3.17">3.17</a></h3>
-<p><!--para 1 -->
+<p><a name="3.17p1" href="#3.17p1"><small>1</small></a>
 <b> value</b><br>
  precise meaning of the contents of an object when interpreted as having a specific type
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.17.1" href="#3.17.1">3.17.1</a></h4>
-<p><!--para 1 -->
+<p><a name="3.17.1p1" href="#3.17.1p1"><small>1</small></a>
 <b> implementation-defined value</b><br>
  unspecified value where each implementation documents how the choice is made
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.17.2" href="#3.17.2">3.17.2</a></h4>
-<p><!--para 1 -->
+<p><a name="3.17.2p1" href="#3.17.2p1"><small>1</small></a>
 <b> indeterminate value</b><br>
  either an unspecified value or a trap representation
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="3.17.3" href="#3.17.3">3.17.3</a></h4>
-<p><!--para 1 -->
+<p><a name="3.17.3p1" href="#3.17.3p1"><small>1</small></a>
 <b> unspecified value</b><br>
  valid value of the relevant type where this International Standard imposes no
  requirements on which value is chosen in any instance
-<p><!--para 2 -->
+<p><a name="3.17.3p2" href="#3.17.3p2"><small>2</small></a>
  NOTE     An unspecified value cannot be a trap representation.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.18" href="#3.18">3.18</a></h3>
-<p><!--para 1 -->
+<p><a name="3.18p1" href="#3.18p1"><small>1</small></a>
 <b> [^ x ^]</b><br>
  ceiling of x: the least integer greater than or equal to x
-<p><!--para 2 -->
+<p><a name="3.18p2" href="#3.18p2"><small>2</small></a>
  EXAMPLE       [^2.4^] is 3, [^-2.4^] is -2.
  
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="3.19" href="#3.19">3.19</a></h3>
-<p><!--para 1 -->
+<p><a name="3.19p1" href="#3.19p1"><small>1</small></a>
 <b> [_ x _]</b><br>
  floor of x: the greatest integer less than or equal to x
-<p><!--para 2 -->
+<p><a name="3.19p2" href="#3.19p2"><small>2</small></a>
  EXAMPLE       [_2.4_] is 2, [_-2.4_] is -3.
 <!--page 19 -->
 
 <p><small><a href="#Contents">Contents</a></small>
 <h2><a name="4" href="#4">4. Conformance</a></h2>
-<p><!--para 1 -->
+<p><a name="4p1" href="#4p1"><small>1</small></a>
  In this International Standard, ''shall'' is to be interpreted as a requirement on an
  implementation or on a program; conversely, ''shall not'' is to be interpreted as a
  prohibition.
-<p><!--para 2 -->
+<p><a name="4p2" href="#4p2"><small>2</small></a>
  If a ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated, the
  behavior is undefined. Undefined behavior is otherwise indicated in this International
  Standard by the words ''undefined behavior'' or by the omission of any explicit definition
  of behavior. There is no difference in emphasis among these three; they all describe
  ''behavior that is undefined''.
-<p><!--para 3 -->
+<p><a name="4p3" href="#4p3"><small>3</small></a>
  A program that is correct in all other aspects, operating on correct data, containing
  unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
-<p><!--para 4 -->
+<p><a name="4p4" href="#4p4"><small>4</small></a>
  The implementation shall not successfully translate a preprocessing translation unit
  containing a #error preprocessing directive unless it is part of a group skipped by
  conditional inclusion.
-<p><!--para 5 -->
+<p><a name="4p5" href="#4p5"><small>5</small></a>
  A strictly conforming program shall use only those features of the language and library
  specified in this International Standard.<sup><a href="#note2"><b>2)</b></a></sup> It shall not produce output dependent on any
  unspecified, undefined, or implementation-defined behavior, and shall not exceed any
  minimum implementation limit.
-<p><!--para 6 -->
+<p><a name="4p6" href="#4p6"><small>6</small></a>
  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
@@ -899,9 +899,9 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  
  
 <!--page 20 -->
-<p><!--para 7 -->
+<p><a name="4p7" href="#4p7"><small>7</small></a>
  A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note4"><b>4)</b></a></sup>
-<p><!--para 8 -->
+<p><a name="4p8" href="#4p8"><small>8</small></a>
  An implementation shall be accompanied by a document that defines all implementation-
  defined and locale-specific characteristics and all extensions.
 <p><b> Forward references</b>: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
@@ -938,7 +938,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h2><a name="5" href="#5">5. Environment</a></h2>
-<p><!--para 1 -->
+<p><a name="5p1" href="#5p1"><small>1</small></a>
  An implementation translates C source files and executes C programs in two data-
  processing-system environments, which will be called the translation environment and
  the execution environment in this International Standard. Their characteristics define and
@@ -955,7 +955,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.1.1" href="#5.1.1.1">5.1.1.1 Program structure</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.1.1p1" href="#5.1.1.1p1"><small>1</small></a>
  A C program need not all be translated at the same time. The text of the program is kept
  in units called source files, (or preprocessing files) in this International Standard. A
  source file together with all the headers and source files included via the preprocessing
@@ -971,7 +971,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.1.2" href="#5.1.1.2">5.1.1.2 Translation phases</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.1.2p1" href="#5.1.1.2p1"><small>1</small></a>
  The precedence among the syntax rules of translation is specified by the following
  phases.<sup><a href="#note5"><b>5)</b></a></sup>
 <ol>
@@ -1037,13 +1037,13 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.1.3" href="#5.1.1.3">5.1.1.3 Diagnostics</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.1.3p1" href="#5.1.1.3p1"><small>1</small></a>
  A conforming implementation shall produce at least one diagnostic message (identified in
  an implementation-defined manner) if a preprocessing translation unit or translation unit
  contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
  specified as undefined or implementation-defined. Diagnostic messages need not be
  produced in other circumstances.<sup><a href="#note8"><b>8)</b></a></sup>
-<p><!--para 2 -->
+<p><a name="5.1.1.3p2" href="#5.1.1.3p2"><small>2</small></a>
  EXAMPLE        An implementation shall issue a diagnostic for the translation unit:
 <pre>
           char i;
@@ -1061,7 +1061,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="5.1.2" href="#5.1.2">5.1.2 Execution environments</a></h4>
-<p><!--para 1 -->
+<p><a name="5.1.2p1" href="#5.1.2p1"><small>1</small></a>
  Two execution environments are defined: freestanding and hosted. In both cases,
  program startup occurs when a designated C function is called by the execution
  environment. All objects with static storage duration shall be initialized (set to their
@@ -1072,18 +1072,18 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.2.1" href="#5.1.2.1">5.1.2.1 Freestanding environment</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.2.1p1" href="#5.1.2.1p1"><small>1</small></a>
  In a freestanding environment (in which C program execution may take place without any
  benefit of an operating system), the name and type of the function called at program
  startup are implementation-defined. Any library facilities available to a freestanding
  program, other than the minimal set required by clause 4, are implementation-defined.
-<p><!--para 2 -->
+<p><a name="5.1.2.1p2" href="#5.1.2.1p2"><small>2</small></a>
  The effect of program termination in a freestanding environment is implementation-
  defined.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.2.2" href="#5.1.2.2">5.1.2.2 Hosted environment</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.2.2p1" href="#5.1.2.2p1"><small>1</small></a>
  A hosted environment need not be provided, but shall conform to the following
  specifications if present.
  
@@ -1094,7 +1094,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.2.2.1" href="#5.1.2.2.1">5.1.2.2.1 Program startup</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.2.2.1p1" href="#5.1.2.2.1p1"><small>1</small></a>
  The function called at program startup is named main. The implementation declares no
  prototype for this function. It shall be defined with a return type of int and with no
  parameters:
@@ -1107,7 +1107,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
          int main(int argc, char *argv[]) { /* ... */ }
 </pre>
  or equivalent;<sup><a href="#note9"><b>9)</b></a></sup> or in some other implementation-defined manner.
-<p><!--para 2 -->
+<p><a name="5.1.2.2.1p2" href="#5.1.2.2.1p2"><small>2</small></a>
  If they are declared, the parameters to the main function shall obey the following
  constraints:
 <ul>
@@ -1137,7 +1137,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.2.2.2" href="#5.1.2.2.2">5.1.2.2.2 Program execution</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.2.2.2p1" href="#5.1.2.2.2p1"><small>1</small></a>
  In a hosted environment, a program may use all the functions, macros, type definitions,
  and objects described in the library clause (clause 7).
  
@@ -1147,7 +1147,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.2.2.3" href="#5.1.2.2.3">5.1.2.2.3 Program termination</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.2.2.3p1" href="#5.1.2.2.3p1"><small>1</small></a>
  If the return type of the main function is a type compatible with int, a return from the
  initial call to the main function is equivalent to calling the exit function with the value
  returned by the main function as its argument;<sup><a href="#note10"><b>10)</b></a></sup> reaching the } that terminates the
@@ -1162,27 +1162,27 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.1.2.3" href="#5.1.2.3">5.1.2.3 Program execution</a></h5>
-<p><!--para 1 -->
+<p><a name="5.1.2.3p1" href="#5.1.2.3p1"><small>1</small></a>
  The semantic descriptions in this International Standard describe the behavior of an
  abstract machine in which issues of optimization are irrelevant.
-<p><!--para 2 -->
+<p><a name="5.1.2.3p2" href="#5.1.2.3p2"><small>2</small></a>
  Accessing a volatile object, modifying an object, modifying a file, or calling a function
  that does any of those operations are all side effects,<sup><a href="#note11"><b>11)</b></a></sup> which are changes in the state of
  the execution environment. Evaluation of an expression may produce side effects. At
  certain specified points in the execution sequence called sequence points, all side effects
  of previous evaluations shall be complete and no side effects of subsequent evaluations
  shall have taken place. (A summary of the sequence points is given in <a href="#C">annex C</a>.)
-<p><!--para 3 -->
+<p><a name="5.1.2.3p3" href="#5.1.2.3p3"><small>3</small></a>
  In the abstract machine, all expressions are evaluated as specified by the semantics. An
  actual implementation need not evaluate part of an expression if it can deduce that its
  value is not used and that no needed side effects are produced (including any caused by
  calling a function or accessing a volatile object).
-<p><!--para 4 -->
+<p><a name="5.1.2.3p4" href="#5.1.2.3p4"><small>4</small></a>
  When the processing of the abstract machine is interrupted by receipt of a signal, only the
  values of objects as of the previous sequence point may be relied on. Objects that may be
  modified between the previous sequence point and the next sequence point need not have
  received their correct values yet.
-<p><!--para 5 -->
+<p><a name="5.1.2.3p5" href="#5.1.2.3p5"><small>5</small></a>
  The least requirements on a conforming implementation are:
 <ul>
 <li>  At sequence points, volatile objects are stable in the sense that previous accesses are
@@ -1199,16 +1199,16 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  appear as soon as possible, to ensure that prompting messages actually appear prior to
  a program waiting for input.
 </ul>
-<p><!--para 6 -->
+<p><a name="5.1.2.3p6" href="#5.1.2.3p6"><small>6</small></a>
  What constitutes an interactive device is implementation-defined.
-<p><!--para 7 -->
+<p><a name="5.1.2.3p7" href="#5.1.2.3p7"><small>7</small></a>
  More stringent correspondences between abstract and actual semantics may be defined by
  each implementation.
-<p><!--para 8 -->
+<p><a name="5.1.2.3p8" href="#5.1.2.3p8"><small>8</small></a>
  EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
  semantics: at every sequence point, the values of the actual objects would agree with those specified by the
  abstract semantics. The keyword volatile would then be redundant.
-<p><!--para 9 -->
+<p><a name="5.1.2.3p9" href="#5.1.2.3p9"><small>9</small></a>
  Alternatively, an implementation might perform various optimizations within each translation unit, such
  that the actual semantics would agree with the abstract semantics only when making function calls across
  translation unit boundaries. In such an implementation, at the time of each function entry and function
@@ -1220,7 +1220,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  would require explicit specification of volatile storage, as well as other implementation-defined
  restrictions.
  
-<p><!--para 10 -->
+<p><a name="5.1.2.3p10" href="#5.1.2.3p10"><small>10</small></a>
  EXAMPLE 2       In executing the fragment
 <pre>
           char c1, c2;
@@ -1232,7 +1232,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
  produce the same result, possibly omitting the promotions.
  
-<p><!--para 11 -->
+<p><a name="5.1.2.3p11" href="#5.1.2.3p11"><small>11</small></a>
  EXAMPLE 3       Similarly, in the fragment
 <pre>
           float f1, f2;
@@ -1244,7 +1244,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
  were replaced by the constant 2.0, which has type double).
 <!--page 27 -->
-<p><!--para 12 -->
+<p><a name="5.1.2.3p12" href="#5.1.2.3p12"><small>12</small></a>
  EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
  semantics. Values are independent of whether they are represented in a register or in memory. For
  example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
@@ -1258,7 +1258,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 </pre>
  the values assigned to d1 and d2 are required to have been converted to float.
  
-<p><!--para 13 -->
+<p><a name="5.1.2.3p13" href="#5.1.2.3p13"><small>13</small></a>
  EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
  precision as well as range. The implementation cannot generally apply the mathematical associative rules
  for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
@@ -1274,7 +1274,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
           y = x / 5.0;                //   not equivalent to y   = x * 0.2;
 </pre>
  
-<p><!--para 14 -->
+<p><a name="5.1.2.3p14" href="#5.1.2.3p14"><small>14</small></a>
  EXAMPLE 6 To illustrate the grouping behavior of expressions, in the following fragment
 <pre>
           int a, b;
@@ -1306,7 +1306,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  above expression statement can be rewritten by the implementation in any of the above ways because the
  same result will occur.
 <!--page 28 -->
-<p><!--para 15 -->
+<p><a name="5.1.2.3p15" href="#5.1.2.3p15"><small>15</small></a>
  EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
  following fragment
 <pre>
@@ -1342,7 +1342,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="5.2.1" href="#5.2.1">5.2.1 Character sets</a></h4>
-<p><!--para 1 -->
+<p><a name="5.2.1p1" href="#5.2.1p1"><small>1</small></a>
  Two sets of characters and their associated collating sequences shall be defined: the set in
  which source files are written (the source character set), and the set interpreted in the
  execution environment (the execution character set). Each set is further divided into a
@@ -1350,13 +1350,13 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  locale-specific members (which are not members of the basic character set) called
  extended characters. The combined set is also called the extended character set. The
  values of the members of the execution character set are implementation-defined.
-<p><!--para 2 -->
+<p><a name="5.2.1p2" href="#5.2.1p2"><small>2</small></a>
  In a character constant or string literal, members of the execution character set shall be
  represented by corresponding members of the source character set or by escape
  sequences consisting of the backslash \ followed by one or more characters. A byte with
  all bits set to 0, called the null character, shall exist in the basic execution character set; it
  is used to terminate a character string.
-<p><!--para 3 -->
+<p><a name="5.2.1p3" href="#5.2.1p3"><small>3</small></a>
  Both the basic source and basic execution character sets shall have the following
  members: the 26 uppercase letters of the Latin alphabet
 <pre>
@@ -1389,17 +1389,17 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  constant, a string literal, a header name, a comment, or a preprocessing token that is never
 <!--page 30 -->
  converted to a token), the behavior is undefined.
-<p><!--para 4 -->
+<p><a name="5.2.1p4" href="#5.2.1p4"><small>4</small></a>
  A letter is an uppercase letter or a lowercase letter as defined above; in this International
  Standard the term does not include other characters that are letters in other alphabets.
-<p><!--para 5 -->
+<p><a name="5.2.1p5" href="#5.2.1p5"><small>5</small></a>
  The universal character name construct provides a way to name other characters.
 <p><b> Forward references</b>: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
  preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.2.1.1" href="#5.2.1.1">5.2.1.1 Trigraph sequences</a></h5>
-<p><!--para 1 -->
+<p><a name="5.2.1.1p1" href="#5.2.1.1p1"><small>1</small></a>
  Before any other processing takes place, each occurrence of one of the following
  sequences of three characters (called trigraph sequences<sup><a href="#note12"><b>12)</b></a></sup>) is replaced with the
  corresponding single character.
@@ -1410,7 +1410,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 </pre>
  No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
  above is not changed.
-<p><!--para 2 -->
+<p><a name="5.2.1.1p2" href="#5.2.1.1p2"><small>2</small></a>
  EXAMPLE 1
 <pre>
            ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)
@@ -1420,7 +1420,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
            #define arraycheck(a, b) a[b] || b[a]
 </pre>
  
-<p><!--para 3 -->
+<p><a name="5.2.1.1p3" href="#5.2.1.1p3"><small>3</small></a>
  EXAMPLE 2      The following source line
 <pre>
            printf("Eh???/n");
@@ -1438,7 +1438,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.2.1.2" href="#5.2.1.2">5.2.1.2 Multibyte characters</a></h5>
-<p><!--para 1 -->
+<p><a name="5.2.1.2p1" href="#5.2.1.2p1"><small>1</small></a>
  The source character set may contain multibyte characters, used to represent members of
  the extended character set. The execution character set may also contain multibyte
  characters, which need not have the same encoding as for the source character set. For
@@ -1459,7 +1459,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <li>  A byte with all bits zero shall be interpreted as a null character independent of shift
  state. Such a byte shall not occur as part of any other multibyte character.
 </ul>
-<p><!--para 2 -->
+<p><a name="5.2.1.2p2" href="#5.2.1.2p2"><small>2</small></a>
  For source files, the following shall hold:
 <ul>
 <li>  An identifier, comment, string literal, character constant, or header name shall begin
@@ -1470,7 +1470,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="5.2.2" href="#5.2.2">5.2.2 Character display semantics</a></h4>
-<p><!--para 1 -->
+<p><a name="5.2.2p1" href="#5.2.2p1"><small>1</small></a>
  The active position is that location on a display device where the next character output by
  the fputc function would appear. The intent of writing a printing character (as defined
  by the isprint function) to a display device is to display a graphic representation of
@@ -1478,7 +1478,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  position on the current line. The direction of writing is locale-specific. If the active
  position is at the final position of a line (if there is one), the behavior of the display device
  is unspecified.
-<p><!--para 2 -->
+<p><a name="5.2.2p2" href="#5.2.2p2"><small>2</small></a>
  Alphabetic escape sequences representing nongraphic characters in the execution
  character set are intended to produce actions on display devices as follows:
 <dl>
@@ -1498,7 +1498,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
      tabulation position. If the active position is at or past the last defined vertical
       tabulation position, the behavior of the display device is unspecified.
 </dl>
-<p><!--para 3 -->
+<p><a name="5.2.2p3" href="#5.2.2p3"><small>3</small></a>
  Each of these escape sequences shall produce a unique implementation-defined value
  which can be stored in a single char object. The external representations in a text file
  need not be identical to the internal representations, and are outside the scope of this
@@ -1507,7 +1507,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="5.2.3" href="#5.2.3">5.2.3 Signals and interrupts</a></h4>
-<p><!--para 1 -->
+<p><a name="5.2.3p1" href="#5.2.3p1"><small>1</small></a>
  Functions shall be implemented such that they may be interrupted at any time by a signal,
  or may be called by a signal handler, or both, with no alteration to earlier, but still active,
  invocations' control flow (after the interruption), function return values, or objects with
@@ -1517,7 +1517,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="5.2.4" href="#5.2.4">5.2.4 Environmental limits</a></h4>
-<p><!--para 1 -->
+<p><a name="5.2.4p1" href="#5.2.4p1"><small>1</small></a>
  Both the translation and execution environments constrain the implementation of
  language translators and libraries. The following summarizes the language-related
  environmental limits on a conforming implementation; the library-related limits are
@@ -1525,7 +1525,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.2.4.1" href="#5.2.4.1">5.2.4.1 Translation limits</a></h5>
-<p><!--para 1 -->
+<p><a name="5.2.4.1p1" href="#5.2.4.1p1"><small>1</small></a>
  The implementation shall be able to translate and execute at least one program that
  contains at least one instance of every one of the following limits:<sup><a href="#note13"><b>13)</b></a></sup>
 <ul>
@@ -1572,7 +1572,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.2.4.2" href="#5.2.4.2">5.2.4.2 Numerical limits</a></h5>
-<p><!--para 1 -->
+<p><a name="5.2.4.2p1" href="#5.2.4.2p1"><small>1</small></a>
  An implementation is required to document all the limits specified in this subclause,
  which are specified in the headers <a href="#7.10">&lt;limits.h&gt;</a> and <a href="#7.7">&lt;float.h&gt;</a>. Additional limits are
  specified in <a href="#7.18">&lt;stdint.h&gt;</a>.
@@ -1580,7 +1580,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.2.4.2.1" href="#5.2.4.2.1">5.2.4.2.1 Sizes of integer types &lt;limits.h&gt;</a></h5>
-<p><!--para 1 -->
+<p><a name="5.2.4.2.1p1" href="#5.2.4.2.1p1"><small>1</small></a>
  The values given below shall be replaced by constant expressions suitable for use in #if
  preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
  following shall be replaced by expressions that have the same type as would an
@@ -1669,7 +1669,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  ULLONG_MAX         18446744073709551615 // 2<sup>64</sup> - 1
 </pre>
 </ul>
-<p><!--para 2 -->
+<p><a name="5.2.4.2.1p2" href="#5.2.4.2.1p2"><small>2</small></a>
  If the value of an object of type char is treated as a signed integer when used in an
  expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
  value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
@@ -1683,7 +1683,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="5.2.4.2.2" href="#5.2.4.2.2">5.2.4.2.2 Characteristics of floating types &lt;float.h&gt;</a></h5>
-<p><!--para 1 -->
+<p><a name="5.2.4.2.2p1" href="#5.2.4.2.2p1"><small>1</small></a>
  The characteristics of floating types are defined in terms of a model that describes a
  representation of floating-point numbers and values that provide information about an
  implementation's floating-point arithmetic.<sup><a href="#note16"><b>16)</b></a></sup> The following parameters are used to
@@ -1695,7 +1695,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
         p          precision (the number of base-b digits in the significand)
         f<sub>k</sub>         nonnegative integers less than b (the significand digits)
 </pre>
-<p><!--para 2 -->
+<p><a name="5.2.4.2.2p2" href="#5.2.4.2.2p2"><small>2</small></a>
  A floating-point number (x) is defined by the following model:
 <pre>
                     p
@@ -1703,7 +1703,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
                    k=1
 </pre>
  
-<p><!--para 3 -->
+<p><a name="5.2.4.2.2p3" href="#5.2.4.2.2p3"><small>3</small></a>
  In addition to normalized floating-point numbers ( f<sub>1</sub> &gt; 0 if x != 0), floating types may be
  able to contain other kinds of floating-point numbers, such as subnormal floating-point
  numbers (x != 0, e = emin , f<sub>1</sub> = 0) and unnormalized floating-point numbers (x != 0,
@@ -1715,26 +1715,26 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  
 <!--page 36 -->
  arithmetic operand.<sup><a href="#note17"><b>17)</b></a></sup>
-<p><!--para 4 -->
+<p><a name="5.2.4.2.2p4" href="#5.2.4.2.2p4"><small>4</small></a>
  An implementation may give zero and non-numeric values (such as infinities and NaNs) a
  sign or may leave them unsigned. Wherever such values are unsigned, any requirement
  in this International Standard to retrieve the sign shall produce an unspecified sign, and
  any requirement to set the sign shall be ignored.
-<p><!--para 5 -->
+<p><a name="5.2.4.2.2p5" href="#5.2.4.2.2p5"><small>5</small></a>
  The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
  <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results is implementation-
  defined, as is the accuracy of the conversion between floating-point internal
  representations and string representations performed by the library functions in
  <a href="#7.19">&lt;stdio.h&gt;</a>, <a href="#7.20">&lt;stdlib.h&gt;</a>, and <a href="#7.24">&lt;wchar.h&gt;</a>. The implementation may state that the
  accuracy is unknown.
-<p><!--para 6 -->
+<p><a name="5.2.4.2.2p6" href="#5.2.4.2.2p6"><small>6</small></a>
  All integer values in the <a href="#7.7">&lt;float.h&gt;</a> header, except FLT_ROUNDS, shall be constant
  expressions suitable for use in #if preprocessing directives; all floating values shall be
  constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
  and FLT_ROUNDS have separate names for all three floating-point types. The floating-point
  model representation is provided for all values except FLT_EVAL_METHOD and
  FLT_ROUNDS.
-<p><!--para 7 -->
+<p><a name="5.2.4.2.2p7" href="#5.2.4.2.2p7"><small>7</small></a>
  The rounding mode for floating-point addition is characterized by the implementation-
  defined value of FLT_ROUNDS:<sup><a href="#note18"><b>18)</b></a></sup>
 <pre>
@@ -1746,7 +1746,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 </pre>
  All other values for FLT_ROUNDS characterize implementation-defined rounding
  behavior.
-<p><!--para 8 -->
+<p><a name="5.2.4.2.2p8" href="#5.2.4.2.2p8"><small>8</small></a>
  Except for assignment and cast (which remove all extra range and precision), the values
  of operations with floating operands and values subject to the usual arithmetic
  conversions and of floating constants are evaluated to a format whose range and precision
@@ -1769,7 +1769,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 </pre>
  All other negative values for FLT_EVAL_METHOD characterize implementation-defined
  behavior.
-<p><!--para 9 -->
+<p><a name="5.2.4.2.2p9" href="#5.2.4.2.2p9"><small>9</small></a>
  The values given in the following list shall be replaced by constant expressions with
  implementation-defined values that are greater or equal in magnitude (absolute value) to
  those shown, with the same sign:
@@ -1842,7 +1842,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
   LDBL_MAX_10_EXP                                +37
 </pre>
 </ul>
-<p><!--para 10 -->
+<p><a name="5.2.4.2.2p10" href="#5.2.4.2.2p10"><small>10</small></a>
  The values given in the following list shall be replaced by constant expressions with
  implementation-defined values that are greater than or equal to those shown:
 <ul>
@@ -1853,7 +1853,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
   LDBL_MAX                                    1E+37
 </pre>
 </ul>
-<p><!--para 11 -->
+<p><a name="5.2.4.2.2p11" href="#5.2.4.2.2p11"><small>11</small></a>
  The values given in the following list shall be replaced by constant expressions with
  implementation-defined (positive) values that are less than or equal to those shown:
 <ul>
@@ -1873,10 +1873,10 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 </pre>
 </ul>
 <p><b>Recommended practice</b>
-<p><!--para 12 -->
+<p><a name="5.2.4.2.2p12" href="#5.2.4.2.2p12"><small>12</small></a>
  Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
  should be the identity function.
-<p><!--para 13 -->
+<p><a name="5.2.4.2.2p13" href="#5.2.4.2.2p13"><small>13</small></a>
  EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
  requirements of this International Standard, and the appropriate values in a <a href="#7.7">&lt;float.h&gt;</a> header for type
  float:
@@ -1899,7 +1899,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
          FLT_MAX_10_EXP                            +38
 </pre>
  
-<p><!--para 14 -->
+<p><a name="5.2.4.2.2p14" href="#5.2.4.2.2p14"><small>14</small></a>
  EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
  single-precision and double-precision normalized numbers in IEC 60559,<sup><a href="#note20"><b>20)</b></a></sup> and the appropriate values in a
  <a href="#7.7">&lt;float.h&gt;</a> header for types float and double:
@@ -1984,7 +1984,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.1" href="#6.1">6.1 Notation</a></h3>
-<p><!--para 1 -->
+<p><a name="6.1p1" href="#6.1p1"><small>1</small></a>
  In the syntax notation used in this clause, syntactic categories (nonterminals) are
  indicated by italic type, and literal words and character set members (terminals) by bold
  type. A colon (:) following a nonterminal introduces its definition. Alternative
@@ -1994,10 +1994,10 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
           { expression<sub>opt</sub> }
 </pre>
  indicates an optional expression enclosed in braces.
-<p><!--para 2 -->
+<p><a name="6.1p2" href="#6.1p2"><small>2</small></a>
  When syntactic categories are referred to in the main text, they are not italicized and
  words are separated by spaces instead of hyphens.
-<p><!--para 3 -->
+<p><a name="6.1p3" href="#6.1p3"><small>3</small></a>
  A summary of the language syntax is given in <a href="#A">annex A</a>.
 
 <p><small><a href="#Contents">Contents</a></small>
@@ -2005,7 +2005,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.2.1" href="#6.2.1">6.2.1 Scopes of identifiers</a></h4>
-<p><!--para 1 -->
+<p><a name="6.2.1p1" href="#6.2.1p1"><small>1</small></a>
  An identifier can denote an object; a function; a tag or a member of a structure, union, or
  enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
  same identifier can denote different entities at different points in the program. A member
@@ -2013,17 +2013,17 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  parameters are not considered further here, because prior to the semantic phase of
  program translation any occurrences of macro names in the source file are replaced by the
  preprocessing token sequences that constitute their macro definitions.
-<p><!--para 2 -->
+<p><a name="6.2.1p2" href="#6.2.1p2"><small>2</small></a>
  For each different entity that an identifier designates, the identifier is visible (i.e., can be
  used) only within a region of program text called its scope. Different entities designated
  by the same identifier either have different scopes, or are in different name spaces. There
  are four kinds of scopes: function, file, block, and function prototype. (A function
  prototype is a declaration of a function that declares the types of its parameters.)
-<p><!--para 3 -->
+<p><a name="6.2.1p3" href="#6.2.1p3"><small>3</small></a>
  A label name is the only kind of identifier that has function scope. It can be used (in a
  goto statement) anywhere in the function in which it appears, and is declared implicitly
  by its syntactic appearance (followed by a : and a statement).
-<p><!--para 4 -->
+<p><a name="6.2.1p4" href="#6.2.1p4"><small>4</small></a>
  Every other identifier has scope determined by the placement of its declaration (in a
  declarator or type specifier). If the declarator or type specifier that declares the identifier
  appears outside of any block or list of parameters, the identifier has file scope, which
@@ -2039,15 +2039,15 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  strict subset of the scope of the other entity (the outer scope). Within the inner scope, the
  identifier designates the entity declared in the inner scope; the entity declared in the outer
  scope is hidden (and not visible) within the inner scope.
-<p><!--para 5 -->
+<p><a name="6.2.1p5" href="#6.2.1p5"><small>5</small></a>
  Unless explicitly stated otherwise, where this International Standard uses the term
  ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
  entity in the relevant name space whose declaration is visible at the point the identifier
  occurs.
-<p><!--para 6 -->
+<p><a name="6.2.1p6" href="#6.2.1p6"><small>6</small></a>
  Two identifiers have the same scope if and only if their scopes terminate at the same
  point.
-<p><!--para 7 -->
+<p><a name="6.2.1p7" href="#6.2.1p7"><small>7</small></a>
  Structure, union, and enumeration tags have scope that begins just after the appearance of
  the tag in a type specifier that declares the tag. Each enumeration constant has scope that
  begins just after the appearance of its defining enumerator in an enumerator list. Any
@@ -2058,20 +2058,20 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.2.2" href="#6.2.2">6.2.2 Linkages of identifiers</a></h4>
-<p><!--para 1 -->
+<p><a name="6.2.2p1" href="#6.2.2p1"><small>1</small></a>
  An identifier declared in different scopes or in the same scope more than once can be
  made to refer to the same object or function by a process called linkage.<sup><a href="#note21"><b>21)</b></a></sup> There are
  three kinds of linkage: external, internal, and none.
-<p><!--para 2 -->
+<p><a name="6.2.2p2" href="#6.2.2p2"><small>2</small></a>
  In the set of translation units and libraries that constitutes an entire program, each
  declaration of a particular identifier with external linkage denotes the same object or
  function. Within one translation unit, each declaration of an identifier with internal
  linkage denotes the same object or function. Each declaration of an identifier with no
  linkage denotes a unique entity.
-<p><!--para 3 -->
+<p><a name="6.2.2p3" href="#6.2.2p3"><small>3</small></a>
  If the declaration of a file scope identifier for an object or a function contains the storage-
  class specifier static, the identifier has internal linkage.<sup><a href="#note22"><b>22)</b></a></sup>
-<p><!--para 4 -->
+<p><a name="6.2.2p4" href="#6.2.2p4"><small>4</small></a>
  For an identifier declared with the storage-class specifier extern in a scope in which a
  
  
@@ -2081,16 +2081,16 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  external linkage, the linkage of the identifier at the later declaration is the same as the
  linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
  declaration specifies no linkage, then the identifier has external linkage.
-<p><!--para 5 -->
+<p><a name="6.2.2p5" href="#6.2.2p5"><small>5</small></a>
  If the declaration of an identifier for a function has no storage-class specifier, its linkage
  is determined exactly as if it were declared with the storage-class specifier extern. If
  the declaration of an identifier for an object has file scope and no storage-class specifier,
  its linkage is external.
-<p><!--para 6 -->
+<p><a name="6.2.2p6" href="#6.2.2p6"><small>6</small></a>
  The following identifiers have no linkage: an identifier declared to be anything other than
  an object or a function; an identifier declared to be a function parameter; a block scope
  identifier for an object declared without the storage-class specifier extern.
-<p><!--para 7 -->
+<p><a name="6.2.2p7" href="#6.2.2p7"><small>7</small></a>
  If, within a translation unit, the same identifier appears with both internal and external
  linkage, the behavior is undefined.
 <p><b> Forward references</b>: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
@@ -2107,7 +2107,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.2.3" href="#6.2.3">6.2.3 Name spaces of identifiers</a></h4>
-<p><!--para 1 -->
+<p><a name="6.2.3p1" href="#6.2.3p1"><small>1</small></a>
  If more than one declaration of a particular identifier is visible at any point in a
  translation unit, the syntactic context disambiguates uses that refer to different entities.
  Thus, there are separate name spaces for various categories of identifiers, as follows:
@@ -2136,24 +2136,24 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.2.4" href="#6.2.4">6.2.4 Storage durations of objects</a></h4>
-<p><!--para 1 -->
+<p><a name="6.2.4p1" href="#6.2.4p1"><small>1</small></a>
  An object has a storage duration that determines its lifetime. There are three storage
  durations: static, automatic, and allocated. Allocated storage is described in <a href="#7.20.3">7.20.3</a>.
-<p><!--para 2 -->
+<p><a name="6.2.4p2" href="#6.2.4p2"><small>2</small></a>
  The lifetime of an object is the portion of program execution during which storage is
  guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note25"><b>25)</b></a></sup> and retains
  its last-stored value throughout its lifetime.<sup><a href="#note26"><b>26)</b></a></sup> If an object is referred to outside of its
  lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
  the object it points to reaches the end of its lifetime.
-<p><!--para 3 -->
+<p><a name="6.2.4p3" href="#6.2.4p3"><small>3</small></a>
  An object whose identifier is declared with external or internal linkage, or with the
  storage-class specifier static has static storage duration. Its lifetime is the entire
  execution of the program and its stored value is initialized only once, prior to program
  startup.
-<p><!--para 4 -->
+<p><a name="6.2.4p4" href="#6.2.4p4"><small>4</small></a>
  An object whose identifier is declared with no linkage and without the storage-class
  specifier static has automatic storage duration.
-<p><!--para 5 -->
+<p><a name="6.2.4p5" href="#6.2.4p5"><small>5</small></a>
  For such an object that does not have a variable length array type, its lifetime extends
  from entry into the block with which it is associated until execution of that block ends in
  any way. (Entering an enclosed block or calling a function suspends, but does not end,
@@ -2162,7 +2162,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  initialization is specified for the object, it is performed each time the declaration is
  reached in the execution of the block; otherwise, the value becomes indeterminate each
  time the declaration is reached.
-<p><!--para 6 -->
+<p><a name="6.2.4p6" href="#6.2.4p6"><small>6</small></a>
  For such an object that does have a variable length array type, its lifetime extends from
  the declaration of the object until execution of the program leaves the scope of the
  declaration.<sup><a href="#note27"><b>27)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
@@ -2188,33 +2188,33 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.2.5" href="#6.2.5">6.2.5 Types</a></h4>
-<p><!--para 1 -->
+<p><a name="6.2.5p1" href="#6.2.5p1"><small>1</small></a>
  The meaning of a value stored in an object or returned by a function is determined by the
  type of the expression used to access it. (An identifier declared to be an object is the
  simplest such expression; the type is specified in the declaration of the identifier.) Types
  are partitioned into object types (types that fully describe objects), function types (types
  that describe functions), and incomplete types (types that describe objects but lack
  information needed to determine their sizes).
-<p><!--para 2 -->
+<p><a name="6.2.5p2" href="#6.2.5p2"><small>2</small></a>
  An object declared as type _Bool is large enough to store the values 0 and 1.
-<p><!--para 3 -->
+<p><a name="6.2.5p3" href="#6.2.5p3"><small>3</small></a>
  An object declared as type char is large enough to store any member of the basic
  execution character set. If a member of the basic execution character set is stored in a
  char object, its value is guaranteed to be nonnegative. If any other character is stored in
  a char object, the resulting value is implementation-defined but shall be within the range
  of values that can be represented in that type.
-<p><!--para 4 -->
+<p><a name="6.2.5p4" href="#6.2.5p4"><small>4</small></a>
  There are five standard signed integer types, designated as signed char, short
  int, int, long int, and long long int. (These and other types may be
  designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
  implementation-defined extended signed integer types.<sup><a href="#note28"><b>28)</b></a></sup> The standard and extended
  signed integer types are collectively called signed integer types.<sup><a href="#note29"><b>29)</b></a></sup>
-<p><!--para 5 -->
+<p><a name="6.2.5p5" href="#6.2.5p5"><small>5</small></a>
  An object declared as type signed char occupies the same amount of storage as a
  ''plain'' char object. A ''plain'' int object has the natural size suggested by the
  architecture of the execution environment (large enough to contain any value in the range
  INT_MIN to INT_MAX as defined in the header <a href="#7.10">&lt;limits.h&gt;</a>).
-<p><!--para 6 -->
+<p><a name="6.2.5p6" href="#6.2.5p6"><small>6</small></a>
  For each of the signed integer types, there is a corresponding (but different) unsigned
  integer type (designated with the keyword unsigned) that uses the same amount of
  storage (including sign information) and has the same alignment requirements. The type
@@ -2227,64 +2227,64 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  
  
 <!--page 46 -->
-<p><!--para 7 -->
+<p><a name="6.2.5p7" href="#6.2.5p7"><small>7</small></a>
  The standard signed integer types and standard unsigned integer types are collectively
  called the standard integer types, the extended signed integer types and extended
  unsigned integer types are collectively called the extended integer types.
-<p><!--para 8 -->
+<p><a name="6.2.5p8" href="#6.2.5p8"><small>8</small></a>
  For any two integer types with the same signedness and different integer conversion rank
  (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
  subrange of the values of the other type.
-<p><!--para 9 -->
+<p><a name="6.2.5p9" href="#6.2.5p9"><small>9</small></a>
  The range of nonnegative values of a signed integer type is a subrange of the
  corresponding unsigned integer type, and the representation of the same value in each
  type is the same.<sup><a href="#note31"><b>31)</b></a></sup> A computation involving unsigned operands can never overflow,
  because a result that cannot be represented by the resulting unsigned integer type is
  reduced modulo the number that is one greater than the largest value that can be
  represented by the resulting type.
-<p><!--para 10 -->
+<p><a name="6.2.5p10" href="#6.2.5p10"><small>10</small></a>
  There are three real floating types, designated as float, double, and long
  double.<sup><a href="#note32"><b>32)</b></a></sup> The set of values of the type float is a subset of the set of values of the
  type double; the set of values of the type double is a subset of the set of values of the
  type long double.
-<p><!--para 11 -->
+<p><a name="6.2.5p11" href="#6.2.5p11"><small>11</small></a>
  There are three complex types, designated as float _Complex, double
  _Complex, and long double _Complex.<sup><a href="#note33"><b>33)</b></a></sup> The real floating and complex types
  are collectively called the floating types.
-<p><!--para 12 -->
+<p><a name="6.2.5p12" href="#6.2.5p12"><small>12</small></a>
  For each floating type there is a corresponding real type, which is always a real floating
  type. For real floating types, it is the same type. For complex types, it is the type given
  by deleting the keyword _Complex from the type name.
-<p><!--para 13 -->
+<p><a name="6.2.5p13" href="#6.2.5p13"><small>13</small></a>
  Each complex type has the same representation and alignment requirements as an array
  type containing exactly two elements of the corresponding real type; the first element is
  equal to the real part, and the second element to the imaginary part, of the complex
  number.
-<p><!--para 14 -->
+<p><a name="6.2.5p14" href="#6.2.5p14"><small>14</small></a>
  The type char, the signed and unsigned integer types, and the floating types are
  collectively called the basic types. Even if the implementation defines two or more basic
  types to have the same representation, they are nevertheless different types.<sup><a href="#note34"><b>34)</b></a></sup>
  
 <!--page 47 -->
-<p><!--para 15 -->
+<p><a name="6.2.5p15" href="#6.2.5p15"><small>15</small></a>
  The three types char, signed char, and unsigned char are collectively called
  the character types. The implementation shall define char to have the same range,
  representation, and behavior as either signed char or unsigned char.<sup><a href="#note35"><b>35)</b></a></sup>
-<p><!--para 16 -->
+<p><a name="6.2.5p16" href="#6.2.5p16"><small>16</small></a>
  An enumeration comprises a set of named integer constant values. Each distinct
  enumeration constitutes a different enumerated type.
-<p><!--para 17 -->
+<p><a name="6.2.5p17" href="#6.2.5p17"><small>17</small></a>
  The type char, the signed and unsigned integer types, and the enumerated types are
  collectively called integer types. The integer and real floating types are collectively called
  real types.
-<p><!--para 18 -->
+<p><a name="6.2.5p18" href="#6.2.5p18"><small>18</small></a>
  Integer and floating types are collectively called arithmetic types. Each arithmetic type
  belongs to one type domain: the real type domain comprises the real types, the complex
  type domain comprises the complex types.
-<p><!--para 19 -->
+<p><a name="6.2.5p19" href="#6.2.5p19"><small>19</small></a>
  The void type comprises an empty set of values; it is an incomplete type that cannot be
  completed.
-<p><!--para 20 -->
+<p><a name="6.2.5p20" href="#6.2.5p20"><small>20</small></a>
  Any number of derived types can be constructed from the object, function, and
  incomplete types, as follows:
 <ul>
@@ -2315,35 +2315,35 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  pointer type from a referenced type is called ''pointer type derivation''.
 </ul>
  These methods of constructing derived types can be applied recursively.
-<p><!--para 21 -->
+<p><a name="6.2.5p21" href="#6.2.5p21"><small>21</small></a>
  Arithmetic types and pointer types are collectively called scalar types. Array and
  structure types are collectively called aggregate types.<sup><a href="#note37"><b>37)</b></a></sup>
-<p><!--para 22 -->
+<p><a name="6.2.5p22" href="#6.2.5p22"><small>22</small></a>
  An array type of unknown size is an incomplete type. It is completed, for an identifier of
  that type, by specifying the size in a later declaration (with internal or external linkage).
  A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
  type. It is completed, for all declarations of that type, by declaring the same structure or
  union tag with its defining content later in the same scope.
-<p><!--para 23 -->
+<p><a name="6.2.5p23" href="#6.2.5p23"><small>23</small></a>
  A type has known constant size if the type is not incomplete and is not a variable length
  array type.
-<p><!--para 24 -->
+<p><a name="6.2.5p24" href="#6.2.5p24"><small>24</small></a>
  Array, function, and pointer types are collectively called derived declarator types. A
  declarator type derivation from a type T is the construction of a derived declarator type
  from T by the application of an array-type, a function-type, or a pointer-type derivation to
  T.
-<p><!--para 25 -->
+<p><a name="6.2.5p25" href="#6.2.5p25"><small>25</small></a>
  A type is characterized by its type category, which is either the outermost derivation of a
  derived type (as noted above in the construction of derived types), or the type itself if the
  type consists of no derived types.
-<p><!--para 26 -->
+<p><a name="6.2.5p26" href="#6.2.5p26"><small>26</small></a>
  Any type so far mentioned is an unqualified type. Each unqualified type has several
  qualified versions of its type,<sup><a href="#note38"><b>38)</b></a></sup> corresponding to the combinations of one, two, or all
  three of the const, volatile, and restrict qualifiers. The qualified or unqualified
  versions of a type are distinct types that belong to the same type category and have the
  same representation and alignment requirements.<sup><a href="#note39"><b>39)</b></a></sup> A derived type is not qualified by the
  qualifiers (if any) of the type from which it is derived.
-<p><!--para 27 -->
+<p><a name="6.2.5p27" href="#6.2.5p27"><small>27</small></a>
  A pointer to void shall have the same representation and alignment requirements as a
  pointer to a character type.<sup><a href="#note39"><b>39)</b></a></sup> Similarly, pointers to qualified or unqualified versions of
  compatible types shall have the same representation and alignment requirements. All
@@ -2354,13 +2354,13 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  as each other. All pointers to union types shall have the same representation and
  alignment requirements as each other. Pointers to other types need not have the same
  representation or alignment requirements.
-<p><!--para 28 -->
+<p><a name="6.2.5p28" href="#6.2.5p28"><small>28</small></a>
  EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
  pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
  whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
  qualified float'' and is a pointer to a qualified type.
  
-<p><!--para 29 -->
+<p><a name="6.2.5p29" href="#6.2.5p29"><small>29</small></a>
  EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
  function returning struct tag''. The array has length five and the function has a single parameter of type
  float. Its type category is array.
@@ -2409,16 +2409,16 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.2.6.1" href="#6.2.6.1">6.2.6.1 General</a></h5>
-<p><!--para 1 -->
+<p><a name="6.2.6.1p1" href="#6.2.6.1p1"><small>1</small></a>
  The representations of all types are unspecified except as stated in this subclause.
-<p><!--para 2 -->
+<p><a name="6.2.6.1p2" href="#6.2.6.1p2"><small>2</small></a>
  Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
  the number, order, and encoding of which are either explicitly specified or
  implementation-defined.
-<p><!--para 3 -->
+<p><a name="6.2.6.1p3" href="#6.2.6.1p3"><small>3</small></a>
  Values stored in unsigned bit-fields and objects of type unsigned char shall be
  represented using a pure binary notation.<sup><a href="#note40"><b>40)</b></a></sup>
-<p><!--para 4 -->
+<p><a name="6.2.6.1p4" href="#6.2.6.1p4"><small>4</small></a>
  Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
  bits, where n is the size of an object of that type, in bytes. The value may be copied into
  an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
@@ -2427,7 +2427,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  bits the bit-field comprises in the addressable storage unit holding it. Two values (other
  than NaNs) with the same object representation compare equal, but values that compare
  equal may have different object representations.
-<p><!--para 5 -->
+<p><a name="6.2.6.1p5" href="#6.2.6.1p5"><small>5</small></a>
  Certain object representations need not represent a value of the object type. If the stored
  value of an object has such a representation and is read by an lvalue expression that does
  not have character type, the behavior is undefined. If such a representation is produced
@@ -2436,17 +2436,17 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  
 <!--page 50 -->
  a trap representation.
-<p><!--para 6 -->
+<p><a name="6.2.6.1p6" href="#6.2.6.1p6"><small>6</small></a>
  When a value is stored in an object of structure or union type, including in a member
  object, the bytes of the object representation that correspond to any padding bytes take
  unspecified values.<sup><a href="#note42"><b>42)</b></a></sup> The value of a structure or union object is never a trap
  representation, even though the value of a member of the structure or union object may be
  a trap representation.
-<p><!--para 7 -->
+<p><a name="6.2.6.1p7" href="#6.2.6.1p7"><small>7</small></a>
  When a value is stored in a member of an object of union type, the bytes of the object
  representation that do not correspond to that member but do correspond to other members
  take unspecified values.
-<p><!--para 8 -->
+<p><a name="6.2.6.1p8" href="#6.2.6.1p8"><small>8</small></a>
  Where an operator is applied to a value that has more than one object representation,
  which object representation is used shall not affect the value of the result.<sup><a href="#note43"><b>43)</b></a></sup> Where a
  value is stored in an object using a type that has more than one object representation for
@@ -2476,14 +2476,14 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.2.6.2" href="#6.2.6.2">6.2.6.2 Integer types</a></h5>
-<p><!--para 1 -->
+<p><a name="6.2.6.2p1" href="#6.2.6.2p1"><small>1</small></a>
  For unsigned integer types other than unsigned char, the bits of the object
  representation shall be divided into two groups: value bits and padding bits (there need
  not be any of the latter). If there are N value bits, each bit shall represent a different
  power of 2 between 1 and 2<sup>N-1</sup> , so that objects of that type shall be capable of
  representing values from 0 to 2<sup>N</sup> - 1 using a pure binary representation; this shall be
  known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note44"><b>44)</b></a></sup>
-<p><!--para 2 -->
+<p><a name="6.2.6.2p2" href="#6.2.6.2p2"><small>2</small></a>
  For signed integer types, the bits of the object representation shall be divided into three
  groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
  
@@ -2503,7 +2503,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  complement), is a trap representation or a normal value. In the case of sign and
  magnitude and ones' complement, if this representation is a normal value it is called a
  negative zero.
-<p><!--para 3 -->
+<p><a name="6.2.6.2p3" href="#6.2.6.2p3"><small>3</small></a>
  If the implementation supports negative zeros, they shall be generated only by:
 <ul>
 <li>  the &amp;, |, ^, ~, &lt;&lt;, and &gt;&gt; operators with arguments that produce such a value;
@@ -2513,16 +2513,16 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 </ul>
  It is unspecified whether these cases actually generate a negative zero or a normal zero,
  and whether a negative zero becomes a normal zero when stored in an object.
-<p><!--para 4 -->
+<p><a name="6.2.6.2p4" href="#6.2.6.2p4"><small>4</small></a>
  If the implementation does not support negative zeros, the behavior of the &amp;, |, ^, ~, &lt;&lt;,
  and &gt;&gt; operators with arguments that would produce such a value is undefined.
-<p><!--para 5 -->
+<p><a name="6.2.6.2p5" href="#6.2.6.2p5"><small>5</small></a>
  The values of any padding bits are unspecified.<sup><a href="#note45"><b>45)</b></a></sup> A valid (non-trap) object representation
  of a signed integer type where the sign bit is zero is a valid object representation of the
  corresponding unsigned type, and shall represent the same value. For any integer type,
  the object representation where all the bits are zero shall be a representation of the value
  zero in that type.
-<p><!--para 6 -->
+<p><a name="6.2.6.2p6" href="#6.2.6.2p6"><small>6</small></a>
  The precision of an integer type is the number of bits it uses to represent values,
  excluding any sign and padding bits. The width of an integer type is the same but
  including any sign bit; thus for unsigned integer types the two values are the same, while
@@ -2547,7 +2547,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.2.7" href="#6.2.7">6.2.7 Compatible type and composite type</a></h4>
-<p><!--para 1 -->
+<p><a name="6.2.7p1" href="#6.2.7p1"><small>1</small></a>
  Two types have compatible type if their types are the same. Additional rules for
  determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
  in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.5">6.7.5</a> for declarators.<sup><a href="#note46"><b>46)</b></a></sup> Moreover, two structure,
@@ -2561,10 +2561,10 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  members shall be declared in the same order. For two structures or unions, corresponding
  bit-fields shall have the same widths. For two enumerations, corresponding members
  shall have the same values.
-<p><!--para 2 -->
+<p><a name="6.2.7p2" href="#6.2.7p2"><small>2</small></a>
  All declarations that refer to the same object or function shall have compatible type;
  otherwise, the behavior is undefined.
-<p><!--para 3 -->
+<p><a name="6.2.7p3" href="#6.2.7p3"><small>3</small></a>
  A composite type can be constructed from two types that are compatible; it is a type that
  is compatible with both of the two types and satisfies the following conditions:
 <ul>
@@ -2577,7 +2577,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  parameters.
 </ul>
  These rules apply recursively to the types from which the two types are derived.
-<p><!--para 4 -->
+<p><a name="6.2.7p4" href="#6.2.7p4"><small>4</small></a>
  For an identifier with internal or external linkage declared in a scope in which a prior
  declaration of that identifier is visible,<sup><a href="#note47"><b>47)</b></a></sup> if the prior declaration specifies internal or
  external linkage, the type of the identifier at the later declaration becomes the composite
@@ -2587,7 +2587,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  
  
 <!--page 53 -->
-<p><!--para 5 -->
+<p><a name="6.2.7p5" href="#6.2.7p5"><small>5</small></a>
  EXAMPLE        Given the following two file scope declarations:
 <pre>
           int f(int (*)(), double (*)[3]);
@@ -2607,13 +2607,13 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.3" href="#6.3">6.3 Conversions</a></h3>
-<p><!--para 1 -->
+<p><a name="6.3p1" href="#6.3p1"><small>1</small></a>
  Several operators convert operand values from one type to another automatically. This
  subclause specifies the result required from such an implicit conversion, as well as those
  that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
  the conversions performed by most ordinary operators; it is supplemented as required by
  the discussion of each operator in <a href="#6.5">6.5</a>.
-<p><!--para 2 -->
+<p><a name="6.3p2" href="#6.3p2"><small>2</small></a>
  Conversion of an operand value to a compatible type causes no change to the value or the
  representation.
 <p><b> Forward references</b>: cast operators (<a href="#6.5.4">6.5.4</a>).
@@ -2623,7 +2623,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.1" href="#6.3.1.1">6.3.1.1 Boolean, characters, and integers</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.1p1" href="#6.3.1.1p1"><small>1</small></a>
  Every integer type has an integer conversion rank defined as follows:
 <ul>
 <li>  No two signed integer types shall have the same rank, even if they have the same
@@ -2647,7 +2647,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <li>  For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
  greater rank than T3, then T1 has greater rank than T3.
 </ul>
-<p><!--para 2 -->
+<p><a name="6.3.1.1p2" href="#6.3.1.1p2"><small>2</small></a>
  The following may be used in an expression wherever an int or unsigned int may
  be used:
 <!--page 55 -->
@@ -2659,7 +2659,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  If an int can represent all values of the original type, the value is converted to an int;
  otherwise, it is converted to an unsigned int. These are called the integer
  promotions.<sup><a href="#note48"><b>48)</b></a></sup> All other types are unchanged by the integer promotions.
-<p><!--para 3 -->
+<p><a name="6.3.1.1p3" href="#6.3.1.1p3"><small>3</small></a>
  The integer promotions preserve value including sign. As discussed earlier, whether a
  ''plain'' char is treated as signed is implementation-defined.
 <p><b> Forward references</b>: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
@@ -2673,20 +2673,20 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.2" href="#6.3.1.2">6.3.1.2 Boolean type</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.2p1" href="#6.3.1.2p1"><small>1</small></a>
  When any scalar value is converted to _Bool, the result is 0 if the value compares equal
  to 0; otherwise, the result is 1.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.3" href="#6.3.1.3">6.3.1.3 Signed and unsigned integers</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.3p1" href="#6.3.1.3p1"><small>1</small></a>
  When a value with integer type is converted to another integer type other than _Bool, if
  the value can be represented by the new type, it is unchanged.
-<p><!--para 2 -->
+<p><a name="6.3.1.3p2" href="#6.3.1.3p2"><small>2</small></a>
  Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
  subtracting one more than the maximum value that can be represented in the new type
  until the value is in the range of the new type.<sup><a href="#note49"><b>49)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.3.1.3p3" href="#6.3.1.3p3"><small>3</small></a>
  Otherwise, the new type is signed and the value cannot be represented in it; either the
  result is implementation-defined or an implementation-defined signal is raised.
 
@@ -2696,11 +2696,11 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.4" href="#6.3.1.4">6.3.1.4 Real floating and integer</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.4p1" href="#6.3.1.4p1"><small>1</small></a>
  When a finite value of real floating type is converted to an integer type other than _Bool,
  the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
  the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup>
-<p><!--para 2 -->
+<p><a name="6.3.1.4p2" href="#6.3.1.4p2"><small>2</small></a>
  When a value of integer type is converted to a real floating type, if the value being
  converted can be represented exactly in the new type, it is unchanged. If the value being
  converted is in the range of values that can be represented but cannot be represented
@@ -2718,11 +2718,11 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.5" href="#6.3.1.5">6.3.1.5 Real floating types</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.5p1" href="#6.3.1.5p1"><small>1</small></a>
  When a float is promoted to double or long double, or a double is promoted
  to long double, its value is unchanged (if the source value is represented in the
  precision and range of its type).
-<p><!--para 2 -->
+<p><a name="6.3.1.5p2" href="#6.3.1.5p2"><small>2</small></a>
  When a double is demoted to float, a long double is demoted to double or
  float, or a value being represented in greater precision and range than required by its
  semantic type (see <a href="#6.3.1.8">6.3.1.8</a>) is explicitly converted (including to its own type), if the value
@@ -2734,24 +2734,24 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.6" href="#6.3.1.6">6.3.1.6 Complex types</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.6p1" href="#6.3.1.6p1"><small>1</small></a>
  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.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.7" href="#6.3.1.7">6.3.1.7 Real and complex</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.7p1" href="#6.3.1.7p1"><small>1</small></a>
  When a value of real type is converted to a complex type, the real part of the complex
  result value is determined by the rules of conversion to the corresponding real type and
  the imaginary part of the complex result value is a positive zero or an unsigned zero.
-<p><!--para 2 -->
+<p><a name="6.3.1.7p2" href="#6.3.1.7p2"><small>2</small></a>
  When a value of complex type is converted to a real type, the imaginary part of the
  complex value is discarded and the value of the real part is converted according to the
  conversion rules for the corresponding real type.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.1.8" href="#6.3.1.8">6.3.1.8 Usual arithmetic conversions</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.1.8p1" href="#6.3.1.8p1"><small>1</small></a>
  Many operators that expect operands of arithmetic type cause conversions and yield result
  types in a similar way. The purpose is to determine a common real type for the operands
  and result. For the specified operands, each operand is converted, without change of type
@@ -2789,7 +2789,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
               corresponding to the type of the operand with signed integer type.
 </ul>
 </ul>
-<p><!--para 2 -->
+<p><a name="6.3.1.8p2" href="#6.3.1.8p2"><small>2</small></a>
  The values of floating operands and of the results of floating expressions may be
  represented in greater precision and range than that required by the type; the types are not
  changed thereby.<sup><a href="#note52"><b>52)</b></a></sup>
@@ -2812,7 +2812,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.2.1" href="#6.3.2.1">6.3.2.1 Lvalues, arrays, and function designators</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.2.1p1" href="#6.3.2.1p1"><small>1</small></a>
  An lvalue is an expression with an object type or an incomplete type other than void;<sup><a href="#note53"><b>53)</b></a></sup>
  if an lvalue does not designate an object when it is evaluated, the behavior is undefined.
  When an object is said to have a particular type, the type is specified by the lvalue used to
@@ -2820,7 +2820,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  not have an incomplete type, does not have a const-qualified type, and if it is a structure
  or union, does not have any member (including, recursively, any member or element of
  all contained aggregates or unions) with a const-qualified type.
-<p><!--para 2 -->
+<p><a name="6.3.2.1p2" href="#6.3.2.1p2"><small>2</small></a>
  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
@@ -2828,13 +2828,13 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  unqualified version of the type of the lvalue; otherwise, the value has the type of the
  lvalue. If the lvalue has an incomplete type and does not have array type, the behavior is
  undefined.
-<p><!--para 3 -->
+<p><a name="6.3.2.1p3" href="#6.3.2.1p3"><small>3</small></a>
  Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a
  string literal used to initialize an array, an expression that has type ''array of type'' is
  converted to an expression with type ''pointer to type'' that points to the initial element of
  the array object and is not an lvalue. If the array object has register storage class, the
  behavior is undefined.
-<p><!--para 4 -->
+<p><a name="6.3.2.1p4" href="#6.3.2.1p4"><small>4</small></a>
  A function designator is an expression that has function type. Except when it is the
  operand of the sizeof operator<sup><a href="#note54"><b>54)</b></a></sup> or the unary &amp; operator, a function designator with
  type ''function returning type'' is converted to an expression that has type ''pointer to
@@ -2861,7 +2861,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.2.2" href="#6.3.2.2">6.3.2.2 void</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.2.2p1" href="#6.3.2.2p1"><small>1</small></a>
  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
@@ -2870,32 +2870,32 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.3.2.3" href="#6.3.2.3">6.3.2.3 Pointers</a></h5>
-<p><!--para 1 -->
+<p><a name="6.3.2.3p1" href="#6.3.2.3p1"><small>1</small></a>
  A pointer to void may be converted to or from a pointer to any incomplete or object
  type. A pointer to any incomplete or object type may be converted to a pointer to void
  and back again; the result shall compare equal to the original pointer.
-<p><!--para 2 -->
+<p><a name="6.3.2.3p2" href="#6.3.2.3p2"><small>2</small></a>
  For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
  the q-qualified version of the type; the values stored in the original and converted pointers
  shall compare equal.
-<p><!--para 3 -->
+<p><a name="6.3.2.3p3" href="#6.3.2.3p3"><small>3</small></a>
  An integer constant expression with the value 0, or such an expression cast to type
  void *, is called a null pointer constant.<sup><a href="#note55"><b>55)</b></a></sup> If a null pointer constant is converted to a
  pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
  to a pointer to any object or function.
-<p><!--para 4 -->
+<p><a name="6.3.2.3p4" href="#6.3.2.3p4"><small>4</small></a>
  Conversion of a null pointer to another pointer type yields a null pointer of that type.
  Any two null pointers shall compare equal.
-<p><!--para 5 -->
+<p><a name="6.3.2.3p5" href="#6.3.2.3p5"><small>5</small></a>
  An integer may be converted to any pointer type. Except as previously specified, the
  result is implementation-defined, might not be correctly aligned, might not point to an
  entity of the referenced type, and might be a trap representation.<sup><a href="#note56"><b>56)</b></a></sup>
-<p><!--para 6 -->
+<p><a name="6.3.2.3p6" href="#6.3.2.3p6"><small>6</small></a>
  Any pointer type may be converted to an integer type. Except as previously specified, the
  result is implementation-defined. If the result cannot be represented in the integer type,
  the behavior is undefined. The result need not be in the range of values of any integer
  type.
-<p><!--para 7 -->
+<p><a name="6.3.2.3p7" href="#6.3.2.3p7"><small>7</small></a>
  A pointer to an object or incomplete type may be converted to a pointer to a different
  object or incomplete type. If the resulting pointer is not correctly aligned<sup><a href="#note57"><b>57)</b></a></sup> for the
  pointed-to type, the behavior is undefined. Otherwise, when converted back again, the
@@ -2906,7 +2906,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  converted to a pointer to a character type, the result points to the lowest addressed byte of
  the object. Successive increments of the result, up to the size of the object, yield pointers
  to the remaining bytes of the object.
-<p><!--para 8 -->
+<p><a name="6.3.2.3p8" href="#6.3.2.3p8"><small>8</small></a>
  A pointer to a function of one type may be converted to a pointer to a function of another
  type and back again; the result shall compare equal to the original pointer. If a converted
  pointer is used to call a function whose type is not compatible with the pointed-to type,
@@ -2929,7 +2929,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.4" href="#6.4">6.4 Lexical elements</a></h3>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4p1" href="#6.4p1"><small>1</small></a>
 <pre>
           token:
                    keyword
@@ -2947,11 +2947,11 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
                  each non-white-space character that cannot be one of the above
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.4p2" href="#6.4p2"><small>2</small></a>
  Each preprocessing token that is converted to a token shall have the lexical form of a
  keyword, an identifier, a constant, a string literal, or a punctuator.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.4p3" href="#6.4p3"><small>3</small></a>
  A token is the minimal lexical element of the language in translation phases 7 and 8. The
  categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
  A preprocessing token is the minimal lexical element of the language in translation
@@ -2970,7 +2970,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  
  
 <!--page 62 -->
-<p><!--para 4 -->
+<p><a name="6.4p4" href="#6.4p4"><small>4</small></a>
  If the input stream has been parsed into preprocessing tokens up to a given character, the
  next preprocessing token is the longest sequence of characters that could constitute a
  preprocessing token. There is one exception to this rule: header name preprocessing
@@ -2978,14 +2978,14 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  implementation-defined locations within #pragma directives. In such contexts, a
  sequence of characters that could be either a header name or a string literal is recognized
  as the former.
-<p><!--para 5 -->
+<p><a name="6.4p5" href="#6.4p5"><small>5</small></a>
  EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
  valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
  might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
  fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
  not E is a macro name.
  
-<p><!--para 6 -->
+<p><a name="6.4p6" href="#6.4p6"><small>6</small></a>
  EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
  increment operators, even though the parse x ++ + ++ y might yield a correct expression.
  
@@ -3003,7 +3003,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.1" href="#6.4.1">6.4.1 Keywords</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.1p1" href="#6.4.1p1"><small>1</small></a>
 <pre>
           keyword: one of
                 auto                    enum                  restrict              unsigned
@@ -3018,7 +3018,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
                 else                    register              union
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.4.1p2" href="#6.4.1p2"><small>2</small></a>
  The above tokens (case sensitive) are reserved (in translation phases 7 and 8) for use as
  keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
  specifying imaginary types.<sup><a href="#note59"><b>59)</b></a></sup>
@@ -3037,7 +3037,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.4.2.1" href="#6.4.2.1">6.4.2.1 General</a></h5>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.2.1p1" href="#6.4.2.1p1"><small>1</small></a>
 <pre>
           identifier:
                  identifier-nondigit
@@ -3056,19 +3056,19 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
                  0 1        2     3    4    5    6     7    8    9
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.4.2.1p2" href="#6.4.2.1p2"><small>2</small></a>
  An identifier is a sequence of nondigit characters (including the underscore _, the
  lowercase and uppercase Latin letters, and other characters) and digits, which designates
  one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
  There is no specific limit on the maximum length of an identifier.
-<p><!--para 3 -->
+<p><a name="6.4.2.1p3" href="#6.4.2.1p3"><small>3</small></a>
  Each universal character name in an identifier shall designate a character whose encoding
  in ISO/IEC 10646 falls into one of the ranges specified in <a href="#D">annex D</a>.<sup><a href="#note60"><b>60)</b></a></sup> The initial
  character shall not be a universal character name designating a digit. An implementation
  may allow multibyte characters that are not part of the basic source character set to
  appear in identifiers; which characters and their correspondence to universal character
  names is implementation-defined.
-<p><!--para 4 -->
+<p><a name="6.4.2.1p4" href="#6.4.2.1p4"><small>4</small></a>
  When preprocessing tokens are converted to tokens during translation phase 7, if a
  preprocessing token could be converted to either a keyword or an identifier, it is converted
  to a keyword.
@@ -3076,13 +3076,13 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
  
 <!--page 64 -->
 <p><b>Implementation limits</b>
-<p><!--para 5 -->
+<p><a name="6.4.2.1p5" href="#6.4.2.1p5"><small>5</small></a>
  As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
  characters in an identifier; the limit for an external name (an identifier that has external
  linkage) may be more restrictive than that for an internal name (a macro name or an
  identifier that does not have external linkage). The number of significant characters in an
  identifier is implementation-defined.
-<p><!--para 6 -->
+<p><a name="6.4.2.1p6" href="#6.4.2.1p6"><small>6</small></a>
  Any identifiers that differ in a significant character are different identifiers. If two
  identifiers differ only in nonsignificant characters, the behavior is undefined.
 <p><b> Forward references</b>: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
@@ -3097,18 +3097,18 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.4.2.2" href="#6.4.2.2">6.4.2.2 Predefined identifiers</a></h5>
 <p><b>Semantics</b>
-<p><!--para 1 -->
+<p><a name="6.4.2.2p1" href="#6.4.2.2p1"><small>1</small></a>
  The identifier __func__ shall be implicitly declared by the translator as if,
  immediately following the opening brace of each function definition, the declaration
 <pre>
           static const char __func__[] = "function-name";
 </pre>
  appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note61"><b>61)</b></a></sup>
-<p><!--para 2 -->
+<p><a name="6.4.2.2p2" href="#6.4.2.2p2"><small>2</small></a>
  This name is encoded as if the implicit declaration had been written in the source
  character set and then translated into the execution character set as indicated in translation
  phase 5.
-<p><!--para 3 -->
+<p><a name="6.4.2.2p3" href="#6.4.2.2p3"><small>3</small></a>
  EXAMPLE        Consider the code fragment:
 <pre>
           #include <a href="#7.19">&lt;stdio.h&gt;</a>
@@ -3138,7 +3138,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.3" href="#6.4.3">6.4.3 Universal character names</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.3p1" href="#6.4.3p1"><small>1</small></a>
 <pre>
           universal-character-name:
                  \u hex-quad
@@ -3148,16 +3148,16 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
                               hexadecimal-digit hexadecimal-digit
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.4.3p2" href="#6.4.3p2"><small>2</small></a>
  A universal character name shall not specify a character whose short identifier is less than
  00A0 other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through
  DFFF inclusive.<sup><a href="#note62"><b>62)</b></a></sup>
 <p><b>Description</b>
-<p><!--para 3 -->
+<p><a name="6.4.3p3" href="#6.4.3p3"><small>3</small></a>
  Universal character names may be used in identifiers, character constants, and string
  literals to designate characters that are not in the basic character set.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.4.3p4" href="#6.4.3p4"><small>4</small></a>
  The universal character name \Unnnnnnnn designates the character whose eight-digit
  short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note63"><b>63)</b></a></sup> Similarly, the universal
  character name \unnnn designates the character whose four-digit short identifier is nnnn
@@ -3179,7 +3179,7 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.4" href="#6.4.4">6.4.4 Constants</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.4p1" href="#6.4.4p1"><small>1</small></a>
 <pre>
           constant:
                  integer-constant
@@ -3188,17 +3188,17 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
                  character-constant
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.4.4p2" href="#6.4.4p2"><small>2</small></a>
  Each constant shall have a type and the value of a constant shall be in the range of
  representable values for its type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.4.4p3" href="#6.4.4p3"><small>3</small></a>
  Each constant has a type, determined by its form and value, as detailed later.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.4.4.1" href="#6.4.4.1">6.4.4.1 Integer constants</a></h5>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.4.1p1" href="#6.4.4.1p1"><small>1</small></a>
 <!--page 67 -->
 <pre>
           integer-constant:
@@ -3237,20 +3237,20 @@ WG14/N1256                Committee Draft -- Septermber 7, 2007
                ll LL
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="6.4.4.1p2" href="#6.4.4.1p2"><small>2</small></a>
  An integer constant begins with a digit, but has no period or exponent part. It may have a
  prefix that specifies its base and a suffix that specifies its type.
-<p><!--para 3 -->
+<p><a name="6.4.4.1p3" href="#6.4.4.1p3"><small>3</small></a>
  A decimal constant begins with a nonzero digit and consists of a sequence of decimal
  digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
  digits 0 through 7 only. A hexadecimal constant consists of the prefix 0x or 0X followed
  by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
  10 through 15 respectively.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.4.4.1p4" href="#6.4.4.1p4"><small>4</small></a>
  The value of a decimal constant is computed base 10; that of an octal constant, base 8;
  that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
-<p><!--para 5 -->
+<p><a name="6.4.4.1p5" href="#6.4.4.1p5"><small>5</small></a>
  The type of an integer constant is the first of the corresponding list in which its value can
  be represented.
 <!--page 68 -->
@@ -3317,7 +3317,7 @@ unsigned long long int
 unsigned long long int
 </pre>
 </table>
-<p><!--para 6 -->
+<p><a name="6.4.4.1p6" href="#6.4.4.1p6"><small>6</small></a>
  If an integer constant cannot be represented by any type in its list, it may have an
  extended integer type, if the extended integer type can represent its value. If all of the
  types in the list for the constant are signed, the extended integer type shall be signed. If
@@ -3330,7 +3330,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.4.4.2" href="#6.4.4.2">6.4.4.2 Floating constants</a></h5>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.4.2p1" href="#6.4.4.2p1"><small>1</small></a>
 <!--page 70 -->
 <pre>
           floating-constant:
@@ -3369,7 +3369,7 @@ unsigned long long int
                  f l F L
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="6.4.4.2p2" href="#6.4.4.2p2"><small>2</small></a>
  A floating constant has a significand part that may be followed by an exponent part and a
  suffix that specifies its type. The components of the significand part may include a digit
  sequence representing the whole-number part, followed by a period (.), followed by a
@@ -3378,7 +3378,7 @@ unsigned long long int
  Either the whole-number part or the fraction part has to be present; for decimal floating
  constants, either the period or the exponent part has to be present.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.4.4.2p3" href="#6.4.4.2p3"><small>3</small></a>
  The significand part is interpreted as a (decimal or hexadecimal) rational number; the
  digit sequence in the exponent part is interpreted as a decimal integer. For decimal
  floating constants, the exponent indicates the power of 10 by which the significand part is
@@ -3389,19 +3389,19 @@ unsigned long long int
  adjacent to the nearest representable value, chosen in an implementation-defined manner.
  For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
  correctly rounded.
-<p><!--para 4 -->
+<p><a name="6.4.4.2p4" href="#6.4.4.2p4"><small>4</small></a>
  An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
  type float. If suffixed by the letter l or L, it has type long double.
-<p><!--para 5 -->
+<p><a name="6.4.4.2p5" href="#6.4.4.2p5"><small>5</small></a>
  Floating constants are converted to internal format as if at translation-time. The
  conversion of a floating constant shall not raise an exceptional condition or a floating-
  point exception at execution time.
 <p><b>Recommended practice</b>
-<p><!--para 6 -->
+<p><a name="6.4.4.2p6" href="#6.4.4.2p6"><small>6</small></a>
  The implementation should produce a diagnostic message if a hexadecimal constant
  cannot be represented exactly in its evaluation format; the implementation should then
  proceed with the translation of the program.
-<p><!--para 7 -->
+<p><a name="6.4.4.2p7" href="#6.4.4.2p7"><small>7</small></a>
  The translation-time conversion of floating constants should match the execution-time
  conversion of character strings by library functions, such as strtod, given matching
  inputs suitable for both conversions, the same result format, and default execution-time
@@ -3420,20 +3420,20 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.4.4.3" href="#6.4.4.3">6.4.4.3 Enumeration constants</a></h5>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.4.3p1" href="#6.4.4.3p1"><small>1</small></a>
 <pre>
           enumeration-constant:
                 identifier
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.4.4.3p2" href="#6.4.4.3p2"><small>2</small></a>
  An identifier declared as an enumeration constant has type int.
 <p><b> Forward references</b>: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.4.4.4" href="#6.4.4.4">6.4.4.4 Character constants</a></h5>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.4.4p1" href="#6.4.4.4p1"><small>1</small></a>
 <!--page 72 -->
 <pre>
           character-constant:
@@ -3463,13 +3463,13 @@ unsigned long long int
                 hexadecimal-escape-sequence hexadecimal-digit
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="6.4.4.4p2" href="#6.4.4.4p2"><small>2</small></a>
  An integer character constant is a sequence of one or more multibyte characters enclosed
  in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
  letter L. With a few exceptions detailed later, the elements of the sequence are any
  members of the source character set; they are mapped in an implementation-defined
  manner to members of the execution character set.
-<p><!--para 3 -->
+<p><a name="6.4.4.4p3" href="#6.4.4.4p3"><small>3</small></a>
  The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
  arbitrary integer values are representable according to the following table of escape
  sequences:
@@ -3481,25 +3481,25 @@ unsigned long long int
         octal character                \octal digits
         hexadecimal character          \x hexadecimal digits
 </pre>
-<p><!--para 4 -->
+<p><a name="6.4.4.4p4" href="#6.4.4.4p4"><small>4</small></a>
  The double-quote " and question-mark ? are representable either by themselves or by the
  escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
  shall be represented, respectively, by the escape sequences \' and \\.
-<p><!--para 5 -->
+<p><a name="6.4.4.4p5" href="#6.4.4.4p5"><small>5</small></a>
  The octal digits that follow the backslash in an octal escape sequence are taken to be part
  of the construction of a single character for an integer character constant or of a single
  wide character for a wide character constant. The numerical value of the octal integer so
  formed specifies the value of the desired character or wide character.
-<p><!--para 6 -->
+<p><a name="6.4.4.4p6" href="#6.4.4.4p6"><small>6</small></a>
  The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
  sequence are taken to be part of the construction of a single character for an integer
  character constant or of a single wide character for a wide character constant. The
  numerical value of the hexadecimal integer so formed specifies the value of the desired
  character or wide character.
-<p><!--para 7 -->
+<p><a name="6.4.4.4p7" href="#6.4.4.4p7"><small>7</small></a>
  Each octal or hexadecimal escape sequence is the longest sequence of characters that can
  constitute the escape sequence.
-<p><!--para 8 -->
+<p><a name="6.4.4.4p8" href="#6.4.4.4p8"><small>8</small></a>
  In addition, characters not in the basic character set are representable by universal
  character names and certain nongraphic characters are representable by escape sequences
  consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
@@ -3510,12 +3510,12 @@ unsigned long long int
  
 <!--page 73 -->
 <p><b>Constraints</b>
-<p><!--para 9 -->
+<p><a name="6.4.4.4p9" href="#6.4.4.4p9"><small>9</small></a>
  The value of an octal or hexadecimal escape sequence shall be in the range of
  representable values for the type unsigned char for an integer character constant, or
  the unsigned type corresponding to wchar_t for a wide character constant.
 <p><b>Semantics</b>
-<p><!--para 10 -->
+<p><a name="6.4.4.4p10" href="#6.4.4.4p10"><small>10</small></a>
  An integer character constant has type int. The value of an integer character constant
  containing a single character that maps to a single-byte execution character is the
  numerical value of the representation of the mapped character interpreted as an integer.
@@ -3525,7 +3525,7 @@ unsigned long long int
  a single character or escape sequence, its value is the one that results when an object with
  type char whose value is that of the single character or escape sequence is converted to
  type int.
-<p><!--para 11 -->
+<p><a name="6.4.4.4p11" href="#6.4.4.4p11"><small>11</small></a>
  A wide character constant has type wchar_t, an integer type defined in the
  <a href="#7.17">&lt;stddef.h&gt;</a> header. The value of a wide character constant containing a single
  multibyte character that maps to a member of the extended execution character set is the
@@ -3534,16 +3534,16 @@ unsigned long long int
  constant containing more than one multibyte character, or containing a multibyte
  character or escape sequence not represented in the extended execution character set, is
  implementation-defined.
-<p><!--para 12 -->
+<p><a name="6.4.4.4p12" href="#6.4.4.4p12"><small>12</small></a>
  EXAMPLE 1      The construction '\0' is commonly used to represent the null character.
  
-<p><!--para 13 -->
+<p><a name="6.4.4.4p13" href="#6.4.4.4p13"><small>13</small></a>
  EXAMPLE 2 Consider implementations that use two's-complement representation for integers and eight
  bits for objects that have type char. In an implementation in which type char has the same range of
  values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
  same range of values as unsigned char, the character constant '\xFF' has the value +255.
  
-<p><!--para 14 -->
+<p><a name="6.4.4.4p14" href="#6.4.4.4p14"><small>14</small></a>
  EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
  specifies an integer character constant containing only one character, since a hexadecimal escape sequence
  is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
@@ -3551,7 +3551,7 @@ unsigned long long int
  escape sequence is terminated after three octal digits. (The value of this two-character integer character
  constant is implementation-defined.)
  
-<p><!--para 15 -->
+<p><a name="6.4.4.4p15" href="#6.4.4.4p15"><small>15</small></a>
  EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
  L'\1234' specifies the implementation-defined value that results from the combination of the values
  0123 and '4'.
@@ -3568,7 +3568,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.5" href="#6.4.5">6.4.5 String literals</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.5p1" href="#6.4.5p1"><small>1</small></a>
 <pre>
           string-literal:
                   " s-char-sequence<sub>opt</sub> "
@@ -3582,24 +3582,24 @@ unsigned long long int
                     escape-sequence
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="6.4.5p2" href="#6.4.5p2"><small>2</small></a>
  A character string literal is a sequence of zero or more multibyte characters enclosed in
  double-quotes, as in "xyz". A wide string literal is the same, except prefixed by the
  letter L.
-<p><!--para 3 -->
+<p><a name="6.4.5p3" href="#6.4.5p3"><small>3</small></a>
  The same considerations apply to each element of the sequence in a character string
  literal or a wide string literal as if it were in an integer character constant or a wide
  character constant, except that the single-quote ' is representable either by itself or by the
  escape sequence \', but the double-quote " shall be represented by the escape sequence
  \".
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.4.5p4" href="#6.4.5p4"><small>4</small></a>
  In translation phase 6, the multibyte character sequences specified by any sequence of
  adjacent character and wide string literal tokens are concatenated into a single multibyte
  character sequence. If any of the tokens are wide string literal tokens, the resulting
  multibyte character sequence is treated as a wide string literal; otherwise, it is treated as a
  character string literal.
-<p><!--para 5 -->
+<p><a name="6.4.5p5" href="#6.4.5p5"><small>5</small></a>
  In translation phase 7, a byte or code of value zero is appended to each multibyte
  character sequence that results from a string literal or literals.<sup><a href="#note66"><b>66)</b></a></sup> The multibyte character
  sequence is then used to initialize an array of static storage duration and length just
@@ -3612,11 +3612,11 @@ unsigned long long int
  sequence, as defined by the mbstowcs function with an implementation-defined current
  locale. The value of a string literal containing a multibyte character or escape sequence
  not represented in the execution character set is implementation-defined.
-<p><!--para 6 -->
+<p><a name="6.4.5p6" href="#6.4.5p6"><small>6</small></a>
  It is unspecified whether these arrays are distinct provided their elements have the
  appropriate values. If the program attempts to modify such an array, the behavior is
  undefined.
-<p><!--para 7 -->
+<p><a name="6.4.5p7" href="#6.4.5p7"><small>7</small></a>
  EXAMPLE       This pair of adjacent character string literals
 <pre>
           "\x12" "3"
@@ -3636,7 +3636,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.6" href="#6.4.6">6.4.6 Punctuators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.6p1" href="#6.4.6p1"><small>1</small></a>
 <pre>
           punctuator: one of
                  [ ] ( ) { } . -&gt;
@@ -3648,14 +3648,14 @@ unsigned long long int
                  &lt;: :&gt; &lt;% %&gt; %: %:%:
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.4.6p2" href="#6.4.6p2"><small>2</small></a>
  A punctuator is a symbol that has independent syntactic and semantic significance.
  Depending on context, it may specify an operation to be performed (which in turn may
  yield a value or a function designator, produce a side effect, or some combination thereof)
  in which case it is known as an operator (other forms of operator also exist in some
  contexts). An operand is an entity on which an operator acts.
 <!--page 76 -->
-<p><!--para 3 -->
+<p><a name="6.4.6p3" href="#6.4.6p3"><small>3</small></a>
  In all aspects of the language, the six tokens<sup><a href="#note67"><b>67)</b></a></sup>
 <pre>
           &lt;:    :&gt;      &lt;%    %&gt;     %:     %:%:
@@ -3678,7 +3678,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.7" href="#6.4.7">6.4.7 Header names</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.7p1" href="#6.4.7p1"><small>1</small></a>
 <pre>
           header-name:
                  &lt; h-char-sequence &gt;
@@ -3697,10 +3697,10 @@ unsigned long long int
                                  the new-line character and "
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.4.7p2" href="#6.4.7p2"><small>2</small></a>
  The sequences in both forms of header names are mapped in an implementation-defined
  manner to headers or external source file names as specified in <a href="#6.10.2">6.10.2</a>.
-<p><!--para 3 -->
+<p><a name="6.4.7p3" href="#6.4.7p3"><small>3</small></a>
  If the characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt; delimiters,
  the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
  
@@ -3711,7 +3711,7 @@ unsigned long long int
  sequence between the " delimiters, the behavior is undefined.<sup><a href="#note69"><b>69)</b></a></sup> Header name
  preprocessing tokens are recognized only within #include preprocessing directives and
  in implementation-defined locations within #pragma directives.<sup><a href="#note70"><b>70)</b></a></sup>
-<p><!--para 4 -->
+<p><a name="6.4.7p4" href="#6.4.7p4"><small>4</small></a>
  EXAMPLE       The following sequence of characters:
 <pre>
           0x3&lt;1/a.h&gt;1e2
@@ -3737,7 +3737,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.8" href="#6.4.8">6.4.8 Preprocessing numbers</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.4.8p1" href="#6.4.8p1"><small>1</small></a>
 <pre>
           pp-number:
                 digit
@@ -3751,14 +3751,14 @@ unsigned long long int
                 pp-number       .
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="6.4.8p2" href="#6.4.8p2"><small>2</small></a>
  A preprocessing number begins with a digit optionally preceded by a period (.) and may
  be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
  p+, p-, P+, or P-.
-<p><!--para 3 -->
+<p><a name="6.4.8p3" href="#6.4.8p3"><small>3</small></a>
  Preprocessing number tokens lexically include all floating and integer constant tokens.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.4.8p4" href="#6.4.8p4"><small>4</small></a>
  A preprocessing number does not have type or a value; it acquires both after a successful
  conversion (as part of translation phase 7) to a floating constant token or an integer
  constant token.
@@ -3768,16 +3768,16 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.4.9" href="#6.4.9">6.4.9 Comments</a></h4>
-<p><!--para 1 -->
+<p><a name="6.4.9p1" href="#6.4.9p1"><small>1</small></a>
  Except within a character constant, a string literal, or a comment, the characters /*
  introduce a comment. The contents of such a comment are examined only to identify
  multibyte characters and to find the characters */ that terminate it.<sup><a href="#note71"><b>71)</b></a></sup>
-<p><!--para 2 -->
+<p><a name="6.4.9p2" href="#6.4.9p2"><small>2</small></a>
  Except within a character constant, a string literal, or a comment, the characters //
  introduce a comment that includes all multibyte characters up to, but not including, the
  next new-line character. The contents of such a comment are examined only to identify
  multibyte characters and to find the terminating new-line character.
-<p><!--para 3 -->
+<p><a name="6.4.9p3" href="#6.4.9p3"><small>3</small></a>
  EXAMPLE
 <pre>
          "a//b"                              //   four-character string literal
@@ -3806,28 +3806,28 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.5" href="#6.5">6.5 Expressions</a></h3>
-<p><!--para 1 -->
+<p><a name="6.5p1" href="#6.5p1"><small>1</small></a>
  An expression is a sequence of operators and operands that specifies computation of a
  value, or that designates an object or a function, or that generates side effects, or that
  performs a combination thereof.
-<p><!--para 2 -->
+<p><a name="6.5p2" href="#6.5p2"><small>2</small></a>
  Between the previous and next sequence point an object shall have its stored value
  modified at most once by the evaluation of an expression.<sup><a href="#note72"><b>72)</b></a></sup> Furthermore, the prior value
  shall be read only to determine the value to be stored.<sup><a href="#note73"><b>73)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.5p3" href="#6.5p3"><small>3</small></a>
  The grouping of operators and operands is indicated by the syntax.<sup><a href="#note74"><b>74)</b></a></sup> Except as specified
  later (for the function-call (), &amp;&amp;, ||, ?:, and comma operators), the order of evaluation
  of subexpressions and the order in which side effects take place are both unspecified.
-<p><!--para 4 -->
+<p><a name="6.5p4" href="#6.5p4"><small>4</small></a>
  Some operators (the unary operator ~, and the binary operators &lt;&lt;, &gt;&gt;, &amp;, ^, and |,
  collectively described as bitwise operators) are required to have operands that have
  integer type. These operators yield values that depend on the internal representations of
  integers, and have implementation-defined and undefined aspects for signed types.
-<p><!--para 5 -->
+<p><a name="6.5p5" href="#6.5p5"><small>5</small></a>
  If an exceptional condition occurs during the evaluation of an expression (that is, if the
  result is not mathematically defined or not in the range of representable values for its
  type), the behavior is undefined.
-<p><!--para 6 -->
+<p><a name="6.5p6" href="#6.5p6"><small>6</small></a>
  The effective type of an object for an access to its stored value is the declared type of the
  object, if any.<sup><a href="#note75"><b>75)</b></a></sup> If a value is stored into an object having no declared type through an
  lvalue having a type that is not a character type, then the type of the lvalue becomes the
@@ -3841,7 +3841,7 @@ unsigned long long int
  value is the effective type of the object from which the value is copied, if it has one. For
  all other accesses to an object having no declared type, the effective type of the object is
  simply the type of the lvalue used for the access.
-<p><!--para 7 -->
+<p><a name="6.5p7" href="#6.5p7"><small>7</small></a>
  An object shall have its stored value accessed only by an lvalue expression that has one of
  the following types:<sup><a href="#note76"><b>76)</b></a></sup>
 <ul>
@@ -3855,7 +3855,7 @@ unsigned long long int
  members (including, recursively, a member of a subaggregate or contained union), or
 <li>  a character type.
 </ul>
-<p><!--para 8 -->
+<p><a name="6.5p8" href="#6.5p8"><small>8</small></a>
  A floating expression may be contracted, that is, evaluated as though it were an atomic
  operation, thereby omitting rounding errors implied by the source code and the
  expression evaluation method.<sup><a href="#note77"><b>77)</b></a></sup> The FP_CONTRACT pragma in <a href="#7.12">&lt;math.h&gt;</a> provides a
@@ -3910,7 +3910,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.1" href="#6.5.1">6.5.1 Primary expressions</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.1p1" href="#6.5.1p1"><small>1</small></a>
 <pre>
           primary-expression:
                  identifier
@@ -3919,16 +3919,16 @@ unsigned long long int
                  ( expression )
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.1p2" href="#6.5.1p2"><small>2</small></a>
  An identifier is a primary expression, provided it has been declared as designating an
  object (in which case it is an lvalue) or a function (in which case it is a function
  designator).<sup><a href="#note79"><b>79)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.5.1p3" href="#6.5.1p3"><small>3</small></a>
  A constant is a primary expression. Its type depends on its form and value, as detailed in
  <a href="#6.4.4">6.4.4</a>.
-<p><!--para 4 -->
+<p><a name="6.5.1p4" href="#6.5.1p4"><small>4</small></a>
  A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
-<p><!--para 5 -->
+<p><a name="6.5.1p5" href="#6.5.1p5"><small>5</small></a>
  A parenthesized expression is a primary expression. Its type and value are identical to
  those of the unparenthesized expression. It is an lvalue, a function designator, or a void
  expression if the unparenthesized expression is, respectively, an lvalue, a function
@@ -3942,7 +3942,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.2" href="#6.5.2">6.5.2 Postfix operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.2p1" href="#6.5.2p1"><small>1</small></a>
 <pre>
           postfix-expression:
                  primary-expression
@@ -3969,18 +3969,18 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.2.1" href="#6.5.2.1">6.5.2.1 Array subscripting</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.2.1p1" href="#6.5.2.1p1"><small>1</small></a>
  One of the expressions shall have type ''pointer to object type'', the other expression shall
  have integer type, and the result has type ''type''.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.2.1p2" href="#6.5.2.1p2"><small>2</small></a>
  A postfix expression followed by an expression in square brackets [] is a subscripted
  designation of an element of an array object. The definition of the subscript operator []
  is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
  apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
  initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
  element of E1 (counting from zero).
-<p><!--para 3 -->
+<p><a name="6.5.2.1p3" href="#6.5.2.1p3"><small>3</small></a>
  Successive subscript operators designate an element of a multidimensional array object.
  If E is an n-dimensional array (n &gt;= 2) with dimensions i x j x . . . x k, then E (used as
  other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
@@ -3988,7 +3988,7 @@ unsigned long long int
  implicitly as a result of subscripting, the result is the pointed-to (n - 1)-dimensional array,
  which itself is converted into a pointer if used as other than an lvalue. It follows from this
  that arrays are stored in row-major order (last subscript varies fastest).
-<p><!--para 4 -->
+<p><a name="6.5.2.1p4" href="#6.5.2.1p4"><small>4</small></a>
  EXAMPLE        Consider the array object defined by the declaration
 <pre>
           int x[3][5];
@@ -4008,30 +4008,30 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.2.2" href="#6.5.2.2">6.5.2.2 Function calls</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.2.2p1" href="#6.5.2.2p1"><small>1</small></a>
  The expression that denotes the called function<sup><a href="#note80"><b>80)</b></a></sup> shall have type pointer to function
  returning void or returning an object type other than an array type.
-<p><!--para 2 -->
+<p><a name="6.5.2.2p2" href="#6.5.2.2p2"><small>2</small></a>
  If the expression that denotes the called function has a type that includes a prototype, the
  number of arguments shall agree with the number of parameters. Each argument shall
  have a type such that its value may be assigned to an object with the unqualified version
  of the type of its corresponding parameter.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.2.2p3" href="#6.5.2.2p3"><small>3</small></a>
  A postfix expression followed by parentheses () containing a possibly empty, comma-
  separated list of expressions is a function call. The postfix expression denotes the called
  function. The list of expressions specifies the arguments to the function.
-<p><!--para 4 -->
+<p><a name="6.5.2.2p4" href="#6.5.2.2p4"><small>4</small></a>
  An argument may be an expression of any object type. In preparing for the call to a
  function, the arguments are evaluated, and each parameter is assigned the value of the
  corresponding argument.<sup><a href="#note81"><b>81)</b></a></sup>
-<p><!--para 5 -->
+<p><a name="6.5.2.2p5" href="#6.5.2.2p5"><small>5</small></a>
  If the expression that denotes the called function has type pointer to function returning an
  object type, the function call expression has the same type as that object type, and has the
  value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void. If
  an attempt is made to modify the result of a function call or to access it after the next
  sequence point, the behavior is undefined.
-<p><!--para 6 -->
+<p><a name="6.5.2.2p6" href="#6.5.2.2p6"><small>6</small></a>
  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
@@ -4053,29 +4053,29 @@ unsigned long long int
 <li>  both types are pointers to qualified or unqualified versions of a character type or
  void.
 </ul>
-<p><!--para 7 -->
+<p><a name="6.5.2.2p7" href="#6.5.2.2p7"><small>7</small></a>
  If the expression that denotes the called function has a type that does include a prototype,
  the arguments are implicitly converted, as if by assignment, to the types of the
  corresponding parameters, taking the type of each parameter to be the unqualified version
  of its declared type. The ellipsis notation in a function prototype declarator causes
  argument type conversion to stop after the last declared parameter. The default argument
  promotions are performed on trailing arguments.
-<p><!--para 8 -->
+<p><a name="6.5.2.2p8" href="#6.5.2.2p8"><small>8</small></a>
  No other conversions are performed implicitly; in particular, the number and types of
  arguments are not compared with those of the parameters in a function definition that
  does not include a function prototype declarator.
-<p><!--para 9 -->
+<p><a name="6.5.2.2p9" href="#6.5.2.2p9"><small>9</small></a>
  If the function is defined with a type that is not compatible with the type (of the
  expression) pointed to by the expression that denotes the called function, the behavior is
  undefined.
-<p><!--para 10 -->
+<p><a name="6.5.2.2p10" href="#6.5.2.2p10"><small>10</small></a>
  The order of evaluation of the function designator, the actual arguments, and
  subexpressions within the actual arguments is unspecified, but there is a sequence point
  before the actual call.
-<p><!--para 11 -->
+<p><a name="6.5.2.2p11" href="#6.5.2.2p11"><small>11</small></a>
  Recursive function calls shall be permitted, both directly and indirectly through any chain
  of other functions.
-<p><!--para 12 -->
+<p><a name="6.5.2.2p12" href="#6.5.2.2p12"><small>12</small></a>
  EXAMPLE       In the function call
 <pre>
          (*pf[f1()]) (f2(), f3() + f4())
@@ -4098,27 +4098,27 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.2.3" href="#6.5.2.3">6.5.2.3 Structure and union members</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.2.3p1" href="#6.5.2.3p1"><small>1</small></a>
  The first operand of the . operator shall have a qualified or unqualified structure or union
  type, and the second operand shall name a member of that type.
-<p><!--para 2 -->
+<p><a name="6.5.2.3p2" href="#6.5.2.3p2"><small>2</small></a>
  The first operand of the -&gt; operator shall have type ''pointer to qualified or unqualified
  structure'' or ''pointer to qualified or unqualified union'', and the second operand shall
  name a member of the type pointed to.
 <!--page 85 -->
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.2.3p3" href="#6.5.2.3p3"><small>3</small></a>
  A postfix expression followed by the . operator and an identifier designates a member of
  a structure or union object. The value is that of the named member,<sup><a href="#note82"><b>82)</b></a></sup> and is an lvalue if
  the first expression is an lvalue. If the first expression has qualified type, the result has
  the so-qualified version of the type of the designated member.
-<p><!--para 4 -->
+<p><a name="6.5.2.3p4" href="#6.5.2.3p4"><small>4</small></a>
  A postfix expression followed by the -&gt; operator and an identifier designates a member
  of a structure or union object. The value is that of the named member of the object to
  which the first expression points, and is an lvalue.<sup><a href="#note83"><b>83)</b></a></sup> If the first expression is a pointer to
  a qualified type, the result has the so-qualified version of the type of the designated
  member.
-<p><!--para 5 -->
+<p><a name="6.5.2.3p5" href="#6.5.2.3p5"><small>5</small></a>
  One special guarantee is made in order to simplify the use of unions: if a union contains
  several structures that share a common initial sequence (see below), and if the union
  object currently contains one of these structures, it is permitted to inspect the common
@@ -4126,11 +4126,11 @@ unsigned long long int
  visible. Two structures share a common initial sequence if corresponding members have
  compatible types (and, for bit-fields, the same widths) for a sequence of one or more
  initial members.
-<p><!--para 6 -->
+<p><a name="6.5.2.3p6" href="#6.5.2.3p6"><small>6</small></a>
  EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
  union, f().x is a valid postfix expression but is not an lvalue.
  
-<p><!--para 7 -->
+<p><a name="6.5.2.3p7" href="#6.5.2.3p7"><small>7</small></a>
  EXAMPLE 2 In:
 <pre>
           struct s { int i; const int ci; };
@@ -4152,7 +4152,7 @@ unsigned long long int
  
  
 <!--page 86 -->
-<p><!--para 8 -->
+<p><a name="6.5.2.3p8" href="#6.5.2.3p8"><small>8</small></a>
  EXAMPLE 3       The following is a valid fragment:
 <pre>
           union {
@@ -4213,18 +4213,18 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.2.4" href="#6.5.2.4">6.5.2.4 Postfix increment and decrement operators</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.2.4p1" href="#6.5.2.4p1"><small>1</small></a>
  The operand of the postfix increment or decrement operator shall have qualified or
  unqualified real or pointer type and shall be a modifiable lvalue.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.2.4p2" href="#6.5.2.4p2"><small>2</small></a>
  The result of the postfix ++ operator is the value of the operand. After the result is
  obtained, the value of the operand is incremented. (That is, the value 1 of the appropriate
  type is added to it.) See the discussions of additive operators and compound assignment
  for information on constraints, types, and conversions and the effects of operations on
  pointers. The side effect of updating the stored value of the operand shall occur between
  the previous and the next sequence point.
-<p><!--para 3 -->
+<p><a name="6.5.2.4p3" href="#6.5.2.4p3"><small>3</small></a>
  The postfix -- operator is analogous to the postfix ++ operator, except that the value of
  the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
  it).
@@ -4233,21 +4233,21 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.2.5" href="#6.5.2.5">6.5.2.5 Compound literals</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.2.5p1" href="#6.5.2.5p1"><small>1</small></a>
  The type name shall specify an object type or an array of unknown size, but not a variable
  length array type.
-<p><!--para 2 -->
+<p><a name="6.5.2.5p2" href="#6.5.2.5p2"><small>2</small></a>
  No initializer shall attempt to provide a value for an object not contained within the entire
  unnamed object specified by the compound literal.
-<p><!--para 3 -->
+<p><a name="6.5.2.5p3" href="#6.5.2.5p3"><small>3</small></a>
  If the compound literal occurs outside the body of a function, the initializer list shall
  consist of constant expressions.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.5.2.5p4" href="#6.5.2.5p4"><small>4</small></a>
  A postfix expression that consists of a parenthesized type name followed by a brace-
  enclosed list of initializers is a compound literal. It provides an unnamed object whose
  value is given by the initializer list.<sup><a href="#note84"><b>84)</b></a></sup>
-<p><!--para 5 -->
+<p><a name="6.5.2.5p5" href="#6.5.2.5p5"><small>5</small></a>
  If the type name specifies an array of unknown size, the size is determined by the
  initializer list as specified in <a href="#6.7.8">6.7.8</a>, and the type of the compound literal is that of the
  completed array type. Otherwise (when the type name specifies an object type), the type
@@ -4256,18 +4256,18 @@ unsigned long long int
  
  
 <!--page 88 -->
-<p><!--para 6 -->
+<p><a name="6.5.2.5p6" href="#6.5.2.5p6"><small>6</small></a>
  The value of the compound literal is that of an unnamed object initialized by the
  initializer list. If the compound literal occurs outside the body of a function, the object
  has static storage duration; otherwise, it has automatic storage duration associated with
  the enclosing block.
-<p><!--para 7 -->
+<p><a name="6.5.2.5p7" href="#6.5.2.5p7"><small>7</small></a>
  All the semantic rules and constraints for initializer lists in <a href="#6.7.8">6.7.8</a> are applicable to
  compound literals.<sup><a href="#note85"><b>85)</b></a></sup>
-<p><!--para 8 -->
+<p><a name="6.5.2.5p8" href="#6.5.2.5p8"><small>8</small></a>
  String literals, and compound literals with const-qualified types, need not designate
  distinct objects.<sup><a href="#note86"><b>86)</b></a></sup>
-<p><!--para 9 -->
+<p><a name="6.5.2.5p9" href="#6.5.2.5p9"><small>9</small></a>
  EXAMPLE 1       The file scope definition
 <pre>
           int *p = (int []){2, 4};
@@ -4276,7 +4276,7 @@ unsigned long long int
  second, four. The expressions in this compound literal are required to be constant. The unnamed object
  has static storage duration.
  
-<p><!--para 10 -->
+<p><a name="6.5.2.5p10" href="#6.5.2.5p10"><small>10</small></a>
  EXAMPLE 2       In contrast, in
 <pre>
           void f(void)
@@ -4291,7 +4291,7 @@ unsigned long long int
  pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
  unnamed object has automatic storage duration.
  
-<p><!--para 11 -->
+<p><a name="6.5.2.5p11" href="#6.5.2.5p11"><small>11</small></a>
  EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
  created using compound literals can be passed to functions without depending on member order:
 <pre>
@@ -4304,7 +4304,7 @@ unsigned long long int
                 &amp;(struct point){.x=3, .y=4});
 </pre>
  
-<p><!--para 12 -->
+<p><a name="6.5.2.5p12" href="#6.5.2.5p12"><small>12</small></a>
  EXAMPLE 4       A read-only compound literal can be specified through constructions like:
 <pre>
           (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}
@@ -4314,7 +4314,7 @@ unsigned long long int
  
  
 <!--page 89 -->
-<p><!--para 13 -->
+<p><a name="6.5.2.5p13" href="#6.5.2.5p13"><small>13</small></a>
  EXAMPLE 5        The following three expressions have different meanings:
 <pre>
           "/tmp/fileXXXXXX"
@@ -4325,7 +4325,7 @@ unsigned long long int
  two have automatic storage duration when they occur within the body of a function, and the first of these
  two is modifiable.
  
-<p><!--para 14 -->
+<p><a name="6.5.2.5p14" href="#6.5.2.5p14"><small>14</small></a>
  EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
  and can even be shared. For example,
 <pre>
@@ -4333,7 +4333,7 @@ unsigned long long int
 </pre>
  might yield 1 if the literals' storage is shared.
  
-<p><!--para 15 -->
+<p><a name="6.5.2.5p15" href="#6.5.2.5p15"><small>15</small></a>
  EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
  linked object. For example, there is no way to write a self-referential compound literal that could be used
  as the function argument in place of the named object endless_zeros below:
@@ -4343,7 +4343,7 @@ unsigned long long int
           eval(endless_zeros);
 </pre>
  
-<p><!--para 16 -->
+<p><a name="6.5.2.5p16" href="#6.5.2.5p16"><small>16</small></a>
  EXAMPLE 8        Each compound literal creates only a single object in a given scope:
 <pre>
           struct s { int i; };
@@ -4358,7 +4358,7 @@ unsigned long long int
           }
 </pre>
  The function f() always returns the value 1.
-<p><!--para 17 -->
+<p><a name="6.5.2.5p17" href="#6.5.2.5p17"><small>17</small></a>
  Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
  lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
  have an indeterminate value, which would result in undefined behavior.
@@ -4379,7 +4379,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.3" href="#6.5.3">6.5.3 Unary operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.3p1" href="#6.5.3p1"><small>1</small></a>
 <pre>
           unary-expression:
                  postfix-expression
@@ -4395,16 +4395,16 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.3.1" href="#6.5.3.1">6.5.3.1 Prefix increment and decrement operators</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.3.1p1" href="#6.5.3.1p1"><small>1</small></a>
  The operand of the prefix increment or decrement operator shall have qualified or
  unqualified real or pointer type and shall be a modifiable lvalue.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.3.1p2" href="#6.5.3.1p2"><small>2</small></a>
  The value of the operand of the prefix ++ operator is incremented. The result is the new
  value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
  See the discussions of additive operators and compound assignment for information on
  constraints, types, side effects, and conversions and the effects of operations on pointers.
-<p><!--para 3 -->
+<p><a name="6.5.3.1p3" href="#6.5.3.1p3"><small>3</small></a>
  The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
  operand is decremented.
 <p><b> Forward references</b>: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
@@ -4412,14 +4412,14 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.3.2" href="#6.5.3.2">6.5.3.2 Address and indirection operators</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.3.2p1" href="#6.5.3.2p1"><small>1</small></a>
  The operand of the unary &amp; operator shall be either a function designator, the result of a
  [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
  not declared with the register storage-class specifier.
-<p><!--para 2 -->
+<p><a name="6.5.3.2p2" href="#6.5.3.2p2"><small>2</small></a>
  The operand of the unary * operator shall have pointer type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.3.2p3" href="#6.5.3.2p3"><small>3</small></a>
  The unary &amp; operator yields the address of its operand. If the operand has type ''type'',
  the result has type ''pointer to type''. If the operand is the result of a unary * operator,
  neither that operator nor the &amp; operator is evaluated and the result is as if both were
@@ -4429,7 +4429,7 @@ unsigned long long int
  the unary * that is implied by the [] is evaluated and the result is as if the &amp; operator
  were removed and the [] operator were changed to a + operator. Otherwise, the result is
  a pointer to the object or function designated by its operand.
-<p><!--para 4 -->
+<p><a name="6.5.3.2p4" href="#6.5.3.2p4"><small>4</small></a>
  The unary * operator denotes indirection. If the operand points to a function, the result is
  a function designator; if it points to an object, the result is an lvalue designating the
  object. If the operand has type ''pointer to type'', the result has type ''type''. If an
@@ -4451,23 +4451,23 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.3.3" href="#6.5.3.3">6.5.3.3 Unary arithmetic operators</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.3.3p1" href="#6.5.3.3p1"><small>1</small></a>
  The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
  integer type; of the ! operator, scalar type.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.3.3p2" href="#6.5.3.3p2"><small>2</small></a>
  The result of the unary + operator is the value of its (promoted) operand. The integer
  promotions are performed on the operand, and the result has the promoted type.
-<p><!--para 3 -->
+<p><a name="6.5.3.3p3" href="#6.5.3.3p3"><small>3</small></a>
  The result of the unary - operator is the negative of its (promoted) operand. The integer
  promotions are performed on the operand, and the result has the promoted type.
-<p><!--para 4 -->
+<p><a name="6.5.3.3p4" href="#6.5.3.3p4"><small>4</small></a>
  The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
  each bit in the result is set if and only if the corresponding bit in the converted operand is
  not set). The integer promotions are performed on the operand, and the result has the
  promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
  to the maximum value representable in that type minus E.
-<p><!--para 5 -->
+<p><a name="6.5.3.3p5" href="#6.5.3.3p5"><small>5</small></a>
  The result of the logical negation operator ! is 0 if the value of its operand compares
  unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int.
  The expression !E is equivalent to (0==E).
@@ -4480,27 +4480,27 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.3.4" href="#6.5.3.4">6.5.3.4 The sizeof operator</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.3.4p1" href="#6.5.3.4p1"><small>1</small></a>
  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.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.3.4p2" href="#6.5.3.4p2"><small>2</small></a>
  The sizeof operator yields the size (in bytes) of its operand, which may be an
  expression or the parenthesized name of a type. The size is determined from the type of
  the operand. The result is an integer. If the type of the operand is a variable length array
  type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
  integer constant.
-<p><!--para 3 -->
+<p><a name="6.5.3.4p3" href="#6.5.3.4p3"><small>3</small></a>
  When applied to an operand that has type char, unsigned char, or signed char,
  (or a qualified version thereof) the result is 1. When applied to an operand that has array
  type, the result is the total number of bytes in the array.<sup><a href="#note88"><b>88)</b></a></sup> When applied to an operand
  that has structure or union type, the result is the total number of bytes in such an object,
  including internal and trailing padding.
-<p><!--para 4 -->
+<p><a name="6.5.3.4p4" href="#6.5.3.4p4"><small>4</small></a>
  The value of the result is implementation-defined, and its type (an unsigned integer type)
  is size_t, defined in <a href="#7.17">&lt;stddef.h&gt;</a> (and other headers).
-<p><!--para 5 -->
+<p><a name="6.5.3.4p5" href="#6.5.3.4p5"><small>5</small></a>
  EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
  allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
  allocate and return a pointer to void. For example:
@@ -4511,13 +4511,13 @@ unsigned long long int
  The implementation of the alloc function should ensure that its return value is aligned suitably for
  conversion to a pointer to double.
  
-<p><!--para 6 -->
+<p><a name="6.5.3.4p6" href="#6.5.3.4p6"><small>6</small></a>
  EXAMPLE 2      Another use of the sizeof operator is to compute the number of elements in an array:
 <pre>
          sizeof array / sizeof array[0]
 </pre>
  
-<p><!--para 7 -->
+<p><a name="6.5.3.4p7" href="#6.5.3.4p7"><small>7</small></a>
  EXAMPLE 3      In this example, the size of a variable length array is computed and returned from a
  function:
 <pre>
@@ -4552,25 +4552,25 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.4" href="#6.5.4">6.5.4 Cast operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.4p1" href="#6.5.4p1"><small>1</small></a>
 <pre>
           cast-expression:
                  unary-expression
                  ( type-name ) cast-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.4p2" href="#6.5.4p2"><small>2</small></a>
  Unless the type name specifies a void type, the type name shall specify qualified or
  unqualified scalar type and the operand shall have scalar type.
-<p><!--para 3 -->
+<p><a name="6.5.4p3" href="#6.5.4p3"><small>3</small></a>
  Conversions that involve pointers, other than where permitted by the constraints of
  <a href="#6.5.16.1">6.5.16.1</a>, shall be specified by means of an explicit cast.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.5.4p4" href="#6.5.4p4"><small>4</small></a>
  Preceding an expression by a parenthesized type name converts the value of the
  expression to the named type. This construction is called a cast.<sup><a href="#note89"><b>89)</b></a></sup> A cast that specifies
  no conversion has no effect on the type or value of an expression.
-<p><!--para 5 -->
+<p><a name="6.5.4p5" href="#6.5.4p5"><small>5</small></a>
  If the value of the expression is represented with greater precision or range than required
  by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
  type of the expression is the same as the named type.
@@ -4590,7 +4590,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.5" href="#6.5.5">6.5.5 Multiplicative operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.5p1" href="#6.5.5p1"><small>1</small></a>
 <pre>
           multiplicative-expression:
                   cast-expression
@@ -4599,19 +4599,19 @@ unsigned long long int
                   multiplicative-expression % cast-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.5p2" href="#6.5.5p2"><small>2</small></a>
  Each of the operands shall have arithmetic type. The operands of the % operator shall
  have integer type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.5p3" href="#6.5.5p3"><small>3</small></a>
  The usual arithmetic conversions are performed on the operands.
-<p><!--para 4 -->
+<p><a name="6.5.5p4" href="#6.5.5p4"><small>4</small></a>
  The result of the binary * operator is the product of the operands.
-<p><!--para 5 -->
+<p><a name="6.5.5p5" href="#6.5.5p5"><small>5</small></a>
  The result of the / operator is the quotient from the division of the first operand by the
  second; the result of the % operator is the remainder. In both operations, if the value of
  the second operand is zero, the behavior is undefined.
-<p><!--para 6 -->
+<p><a name="6.5.5p6" href="#6.5.5p6"><small>6</small></a>
  When integers are divided, the result of the / operator is the algebraic quotient with any
  fractional part discarded.<sup><a href="#note90"><b>90)</b></a></sup> If the quotient a/b is representable, the expression
  (a/b)*b + a%b shall equal a.
@@ -4623,7 +4623,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.6" href="#6.5.6">6.5.6 Additive operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.6p1" href="#6.5.6p1"><small>1</small></a>
 <pre>
           additive-expression:
                   multiplicative-expression
@@ -4631,11 +4631,11 @@ unsigned long long int
                   additive-expression - multiplicative-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.6p2" href="#6.5.6p2"><small>2</small></a>
  For addition, either both operands shall have arithmetic type, or one operand shall be a
  pointer to an object type and the other shall have integer type. (Incrementing is
  equivalent to adding 1.)
-<p><!--para 3 -->
+<p><a name="6.5.6p3" href="#6.5.6p3"><small>3</small></a>
  For subtraction, one of the following shall hold:
 <ul>
 <li>  both operands have arithmetic type;
@@ -4649,19 +4649,19 @@ unsigned long long int
 </ul>
  (Decrementing is equivalent to subtracting 1.)
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.5.6p4" href="#6.5.6p4"><small>4</small></a>
  If both operands have arithmetic type, the usual arithmetic conversions are performed on
  them.
-<p><!--para 5 -->
+<p><a name="6.5.6p5" href="#6.5.6p5"><small>5</small></a>
  The result of the binary + operator is the sum of the operands.
-<p><!--para 6 -->
+<p><a name="6.5.6p6" href="#6.5.6p6"><small>6</small></a>
  The result of the binary - operator is the difference resulting from the subtraction of the
  second operand from the first.
-<p><!--para 7 -->
+<p><a name="6.5.6p7" href="#6.5.6p7"><small>7</small></a>
  For the purposes of these operators, a pointer to an object that is not an element of an
  array behaves the same as a pointer to the first element of an array of length one with the
  type of the object as its element type.
-<p><!--para 8 -->
+<p><a name="6.5.6p8" href="#6.5.6p8"><small>8</small></a>
  When an expression that has integer type is added to or subtracted from a pointer, the
  result has the type of the pointer operand. If the pointer operand points to an element of
  an array object, and the array is large enough, the result points to an element offset from
@@ -4677,7 +4677,7 @@ unsigned long long int
  element of the array object, the evaluation shall not produce an overflow; otherwise, the
  behavior is undefined. If the result points one past the last element of the array object, it
  shall not be used as the operand of a unary * operator that is evaluated.
-<p><!--para 9 -->
+<p><a name="6.5.6p9" href="#6.5.6p9"><small>9</small></a>
  When two pointers are subtracted, both shall point to elements of the same array object,
  or one past the last element of the array object; the result is the difference of the
  subscripts of the two array elements. The size of the result is implementation-defined,
@@ -4692,7 +4692,7 @@ unsigned long long int
  value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the
  expression P points one past the last element of the array object, even though the
  expression (Q)+1 does not point to an element of the array object.<sup><a href="#note91"><b>91)</b></a></sup>
-<p><!--para 10 -->
+<p><a name="6.5.6p10" href="#6.5.6p10"><small>10</small></a>
  EXAMPLE        Pointer arithmetic is well defined with pointers to variable length array types.
 <pre>
           {
@@ -4704,7 +4704,7 @@ unsigned long long int
                    n = p - a;                  //   n == 1
           }
 </pre>
-<p><!--para 11 -->
+<p><a name="6.5.6p11" href="#6.5.6p11"><small>11</small></a>
  If array a in the above example were declared to be an array of known constant size, and pointer p were
  declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
  the same.
@@ -4726,7 +4726,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.7" href="#6.5.7">6.5.7 Bitwise shift operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.7p1" href="#6.5.7p1"><small>1</small></a>
 <pre>
           shift-expression:
                   additive-expression
@@ -4734,10 +4734,10 @@ unsigned long long int
                   shift-expression &gt;&gt; additive-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.7p2" href="#6.5.7p2"><small>2</small></a>
  Each of the operands shall have integer type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.7p3" href="#6.5.7p3"><small>3</small></a>
  The integer promotions are performed on each of the operands. The type of the result is
  that of the promoted left operand. If the value of the right operand is negative or is
  greater than or equal to the width of the promoted left operand, the behavior is undefined.
@@ -4746,13 +4746,13 @@ unsigned long long int
  
  
 <!--page 97 -->
-<p><!--para 4 -->
+<p><a name="6.5.7p4" href="#6.5.7p4"><small>4</small></a>
  The result of E1 &lt;&lt; E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
  zeros. If E1 has an unsigned type, the value of the result is E1 x 2<sup>E2</sup> , reduced modulo
  one more than the maximum value representable in the result type. If E1 has a signed
  type and nonnegative value, and E1 x 2<sup>E2</sup> is representable in the result type, then that is
  the resulting value; otherwise, the behavior is undefined.
-<p><!--para 5 -->
+<p><a name="6.5.7p5" href="#6.5.7p5"><small>5</small></a>
  The result of E1 &gt;&gt; E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
  or if E1 has a signed type and a nonnegative value, the value of the result is the integral
  part of the quotient of E1 / 2<sup>E2</sup> . If E1 has a signed type and a negative value, the
@@ -4761,7 +4761,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.8" href="#6.5.8">6.5.8 Relational operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.8p1" href="#6.5.8p1"><small>1</small></a>
 <pre>
           relational-expression:
                   shift-expression
@@ -4771,7 +4771,7 @@ unsigned long long int
                   relational-expression   &gt;=   shift-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.8p2" href="#6.5.8p2"><small>2</small></a>
  One of the following shall hold:
 <ul>
 <li>  both operands have real type;
@@ -4781,14 +4781,14 @@ unsigned long long int
  incomplete types.
 </ul>
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.8p3" href="#6.5.8p3"><small>3</small></a>
  If both of the operands have arithmetic type, the usual arithmetic conversions are
  performed.
-<p><!--para 4 -->
+<p><a name="6.5.8p4" href="#6.5.8p4"><small>4</small></a>
  For the purposes of these operators, a pointer to an object that is not an element of an
  array behaves the same as a pointer to the first element of an array of length one with the
  type of the object as its element type.
-<p><!--para 5 -->
+<p><a name="6.5.8p5" href="#6.5.8p5"><small>5</small></a>
  When two pointers are compared, the result depends on the relative locations in the
  address space of the objects pointed to. If two pointers to object or incomplete types both
  point to the same object, or both point one past the last element of the same array object,
@@ -4801,7 +4801,7 @@ unsigned long long int
  expression P points to an element of an array object and the expression Q points to the
  last element of the same array object, the pointer expression Q+1 compares greater than
  P. In all other cases, the behavior is undefined.
-<p><!--para 6 -->
+<p><a name="6.5.8p6" href="#6.5.8p6"><small>6</small></a>
  Each of the operators &lt; (less than), &gt; (greater than), &lt;= (less than or equal to), and &gt;=
  (greater than or equal to) shall yield 1 if the specified relation is true and 0 if it is false.<sup><a href="#note92"><b>92)</b></a></sup>
  The result has type int.
@@ -4814,7 +4814,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.9" href="#6.5.9">6.5.9 Equality operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.9p1" href="#6.5.9p1"><small>1</small></a>
 <pre>
           equality-expression:
                   relational-expression
@@ -4822,7 +4822,7 @@ unsigned long long int
                  equality-expression != relational-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.9p2" href="#6.5.9p2"><small>2</small></a>
  One of the following shall hold:
 <ul>
 <li>  both operands have arithmetic type;
@@ -4832,12 +4832,12 @@ unsigned long long int
 <li>  one operand is a pointer and the other is a null pointer constant.
 </ul>
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.9p3" href="#6.5.9p3"><small>3</small></a>
  The == (equal to) and != (not equal to) operators are analogous to the relational
  operators except for their lower precedence.<sup><a href="#note93"><b>93)</b></a></sup> Each of the operators yields 1 if the
  specified relation is true and 0 if it is false. The result has type int. For any pair of
  operands, exactly one of the relations is true.
-<p><!--para 4 -->
+<p><a name="6.5.9p4" href="#6.5.9p4"><small>4</small></a>
  If both of the operands have arithmetic type, the usual arithmetic conversions are
  performed. Values of complex types are equal if and only if both their real parts are equal
  and also their imaginary parts are equal. Any two values of arithmetic types from
@@ -4846,19 +4846,19 @@ unsigned long long int
  
  
 <!--page 99 -->
-<p><!--para 5 -->
+<p><a name="6.5.9p5" href="#6.5.9p5"><small>5</small></a>
  Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
  null pointer constant, the null pointer constant is converted to the type of the pointer. If
  one operand is a pointer to an object or incomplete type and the other is a pointer to a
  qualified or unqualified version of void, the former is converted to the type of the latter.
-<p><!--para 6 -->
+<p><a name="6.5.9p6" href="#6.5.9p6"><small>6</small></a>
  Two pointers compare equal if and only if both are null pointers, both are pointers to the
  same object (including a pointer to an object and a subobject at its beginning) or function,
  both are pointers to one past the last element of the same array object, or one is a pointer
  to one past the end of one array object and the other is a pointer to the start of a different
  array object that happens to immediately follow the first array object in the address
  space.<sup><a href="#note94"><b>94)</b></a></sup>
-<p><!--para 7 -->
+<p><a name="6.5.9p7" href="#6.5.9p7"><small>7</small></a>
  For the purposes of these operators, a pointer to an object that is not an element of an
  array behaves the same as a pointer to the first element of an array of length one with the
  type of the object as its element type.
@@ -4876,19 +4876,19 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.10" href="#6.5.10">6.5.10 Bitwise AND operator</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.10p1" href="#6.5.10p1"><small>1</small></a>
 <pre>
           AND-expression:
                 equality-expression
                 AND-expression &amp; equality-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.10p2" href="#6.5.10p2"><small>2</small></a>
  Each of the operands shall have integer type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.10p3" href="#6.5.10p3"><small>3</small></a>
  The usual arithmetic conversions are performed on the operands.
-<p><!--para 4 -->
+<p><a name="6.5.10p4" href="#6.5.10p4"><small>4</small></a>
  The result of the binary &amp; operator is the bitwise AND of the operands (that is, each bit in
  the result is set if and only if each of the corresponding bits in the converted operands is
  set).
@@ -4901,19 +4901,19 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.11" href="#6.5.11">6.5.11 Bitwise exclusive OR operator</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.11p1" href="#6.5.11p1"><small>1</small></a>
 <pre>
           exclusive-OR-expression:
                   AND-expression
                   exclusive-OR-expression ^ AND-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.11p2" href="#6.5.11p2"><small>2</small></a>
  Each of the operands shall have integer type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.11p3" href="#6.5.11p3"><small>3</small></a>
  The usual arithmetic conversions are performed on the operands.
-<p><!--para 4 -->
+<p><a name="6.5.11p4" href="#6.5.11p4"><small>4</small></a>
  The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
  in the result is set if and only if exactly one of the corresponding bits in the converted
  operands is set).
@@ -4921,19 +4921,19 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.12" href="#6.5.12">6.5.12 Bitwise inclusive OR operator</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.12p1" href="#6.5.12p1"><small>1</small></a>
 <pre>
           inclusive-OR-expression:
                   exclusive-OR-expression
                   inclusive-OR-expression | exclusive-OR-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.12p2" href="#6.5.12p2"><small>2</small></a>
  Each of the operands shall have integer type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.12p3" href="#6.5.12p3"><small>3</small></a>
  The usual arithmetic conversions are performed on the operands.
-<p><!--para 4 -->
+<p><a name="6.5.12p4" href="#6.5.12p4"><small>4</small></a>
  The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
  the result is set if and only if at least one of the corresponding bits in the converted
  operands is set).
@@ -4942,20 +4942,20 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.13" href="#6.5.13">6.5.13 Logical AND operator</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.13p1" href="#6.5.13p1"><small>1</small></a>
 <pre>
            logical-AND-expression:
                    inclusive-OR-expression
                    logical-AND-expression &amp;&amp; inclusive-OR-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.13p2" href="#6.5.13p2"><small>2</small></a>
  Each of the operands shall have scalar type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.13p3" href="#6.5.13p3"><small>3</small></a>
  The &amp;&amp; operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
  yields 0. The result has type int.
-<p><!--para 4 -->
+<p><a name="6.5.13p4" href="#6.5.13p4"><small>4</small></a>
  Unlike the bitwise binary &amp; operator, the &amp;&amp; operator guarantees left-to-right evaluation;
  there is a sequence point after the evaluation of the first operand. If the first operand
  compares equal to 0, the second operand is not evaluated.
@@ -4963,20 +4963,20 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.14" href="#6.5.14">6.5.14 Logical OR operator</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.14p1" href="#6.5.14p1"><small>1</small></a>
 <pre>
            logical-OR-expression:
                    logical-AND-expression
                    logical-OR-expression || logical-AND-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.14p2" href="#6.5.14p2"><small>2</small></a>
  Each of the operands shall have scalar type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.14p3" href="#6.5.14p3"><small>3</small></a>
  The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
  yields 0. The result has type int.
-<p><!--para 4 -->
+<p><a name="6.5.14p4" href="#6.5.14p4"><small>4</small></a>
  Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; there is
  a sequence point after the evaluation of the first operand. If the first operand compares
  unequal to 0, the second operand is not evaluated.
@@ -4985,16 +4985,16 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.15" href="#6.5.15">6.5.15 Conditional operator</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.15p1" href="#6.5.15p1"><small>1</small></a>
 <pre>
           conditional-expression:
                  logical-OR-expression
                  logical-OR-expression ? expression : conditional-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.15p2" href="#6.5.15p2"><small>2</small></a>
  The first operand shall have scalar type.
-<p><!--para 3 -->
+<p><a name="6.5.15p3" href="#6.5.15p3"><small>3</small></a>
  One of the following shall hold for the second and third operands:
 <ul>
 <li>  both operands have arithmetic type;
@@ -5006,19 +5006,19 @@ unsigned long long int
  qualified or unqualified version of void.
 </ul>
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.5.15p4" href="#6.5.15p4"><small>4</small></a>
  The first operand is evaluated; there is a sequence point after its evaluation. The second
  operand is evaluated only if the first compares unequal to 0; the third operand is evaluated
  only if the first compares equal to 0; the result is the value of the second or third operand
  (whichever is evaluated), converted to the type described below.<sup><a href="#note95"><b>95)</b></a></sup> If an attempt is made
  to modify the result of a conditional operator or to access it after the next sequence point,
  the behavior is undefined.
-<p><!--para 5 -->
+<p><a name="6.5.15p5" href="#6.5.15p5"><small>5</small></a>
  If both the second and third operands have arithmetic type, the result type that would be
  determined by the usual arithmetic conversions, were they applied to those two operands,
  is the type of the result. If both the operands have structure or union type, the result has
  that type. If both operands have void type, the result has void type.
-<p><!--para 6 -->
+<p><a name="6.5.15p6" href="#6.5.15p6"><small>6</small></a>
  If both the second and third operands are pointers or one is a null pointer constant and the
  other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
  of the types pointed-to by both operands. Furthermore, if both operands are pointers to
@@ -5029,11 +5029,11 @@ unsigned long long int
  
 <!--page 103 -->
  pointer to an appropriately qualified version of void.
-<p><!--para 7 -->
+<p><a name="6.5.15p7" href="#6.5.15p7"><small>7</small></a>
  EXAMPLE The common type that results when the second and third operands are pointers is determined
  in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
  pointers have compatible types.
-<p><!--para 8 -->
+<p><a name="6.5.15p8" href="#6.5.15p8"><small>8</small></a>
  Given the declarations
 <pre>
           const void *c_vp;
@@ -5062,7 +5062,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.16" href="#6.5.16">6.5.16 Assignment operators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.16p1" href="#6.5.16p1"><small>1</small></a>
 <pre>
           assignment-expression:
                  conditional-expression
@@ -5071,17 +5071,17 @@ unsigned long long int
                  = *= /= %= +=                       -=     &lt;&lt;=      &gt;&gt;=      &amp;=     ^=     |=
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.5.16p2" href="#6.5.16p2"><small>2</small></a>
  An assignment operator shall have a modifiable lvalue as its left operand.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.16p3" href="#6.5.16p3"><small>3</small></a>
  An assignment operator stores a value in the object designated by the left operand. An
  assignment expression has the value of the left operand after the assignment, but is not an
  lvalue. The type of an assignment expression is the type of the left operand unless the
  left operand has qualified type, in which case it is the unqualified version of the type of
  the left operand. The side effect of updating the stored value of the left operand shall
  occur between the previous and the next sequence point.
-<p><!--para 4 -->
+<p><a name="6.5.16p4" href="#6.5.16p4"><small>4</small></a>
  The order of evaluation of the operands is unspecified. If an attempt is made to modify
  the result of an assignment operator or to access it after the next sequence point, the
  behavior is undefined.
@@ -5090,7 +5090,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.16.1" href="#6.5.16.1">6.5.16.1 Simple assignment</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.16.1p1" href="#6.5.16.1p1"><small>1</small></a>
  One of the following shall hold:<sup><a href="#note96"><b>96)</b></a></sup>
 <ul>
 <li>  the left operand has qualified or unqualified arithmetic type and the right has
@@ -5107,16 +5107,16 @@ unsigned long long int
 <li>  the left operand has type _Bool and the right is a pointer.
 </ul>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.16.1p2" href="#6.5.16.1p2"><small>2</small></a>
  In simple assignment (=), the value of the right operand is converted to the type of the
  assignment expression and replaces the value stored in the object designated by the left
  operand.
-<p><!--para 3 -->
+<p><a name="6.5.16.1p3" href="#6.5.16.1p3"><small>3</small></a>
  If the value being stored in an object is read from another object that overlaps in any way
  the storage of the first object, then the overlap shall be exact and the two objects shall
  have qualified or unqualified versions of a compatible type; otherwise, the behavior is
  undefined.
-<p><!--para 4 -->
+<p><a name="6.5.16.1p4" href="#6.5.16.1p4"><small>4</small></a>
  EXAMPLE 1       In the program fragment
 <pre>
          int f(void);
@@ -5135,7 +5135,7 @@ unsigned long long int
  negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
  variable c should be declared as int.
  
-<p><!--para 5 -->
+<p><a name="6.5.16.1p5" href="#6.5.16.1p5"><small>5</small></a>
  EXAMPLE 2       In the fragment:
 <pre>
          char c;
@@ -5147,7 +5147,7 @@ unsigned long long int
  of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
  that is, long int type.
  
-<p><!--para 6 -->
+<p><a name="6.5.16.1p6" href="#6.5.16.1p6"><small>6</small></a>
  EXAMPLE 3       Consider the fragment:
 <pre>
          const char **cpp;
@@ -5171,15 +5171,15 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.5.16.2" href="#6.5.16.2">6.5.16.2 Compound assignment</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.5.16.2p1" href="#6.5.16.2p1"><small>1</small></a>
  For the operators += and -= only, either the left operand shall be a pointer to an object
  type and the right shall have integer type, or the left operand shall have qualified or
  unqualified arithmetic type and the right shall have arithmetic type.
-<p><!--para 2 -->
+<p><a name="6.5.16.2p2" href="#6.5.16.2p2"><small>2</small></a>
  For the other operators, each operand shall have arithmetic type consistent with those
  allowed by the corresponding binary operator.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.5.16.2p3" href="#6.5.16.2p3"><small>3</small></a>
  A compound assignment of the form E1 op = E2 differs from the simple assignment
  expression E1 = E1 op (E2) only in that the lvalue E1 is evaluated only once.
 <!--page 106 -->
@@ -5187,19 +5187,19 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.5.17" href="#6.5.17">6.5.17 Comma operator</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.5.17p1" href="#6.5.17p1"><small>1</small></a>
 <pre>
           expression:
                  assignment-expression
                  expression , assignment-expression
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.5.17p2" href="#6.5.17p2"><small>2</small></a>
  The left operand of a comma operator is evaluated as a void expression; there is a
  sequence point after its evaluation. Then the right operand is evaluated; the result has its
  type and value.<sup><a href="#note97"><b>97)</b></a></sup> If an attempt is made to modify the result of a comma operator or to
  access it after the next sequence point, the behavior is undefined.
-<p><!--para 3 -->
+<p><a name="6.5.17p3" href="#6.5.17p3"><small>3</small></a>
  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
@@ -5223,37 +5223,37 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.6" href="#6.6">6.6 Constant expressions</a></h3>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.6p1" href="#6.6p1"><small>1</small></a>
 <pre>
           constant-expression:
                  conditional-expression
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="6.6p2" href="#6.6p2"><small>2</small></a>
  A constant expression can be evaluated during translation rather than runtime, and
  accordingly may be used in any place that a constant may be.
 <p><b>Constraints</b>
-<p><!--para 3 -->
+<p><a name="6.6p3" href="#6.6p3"><small>3</small></a>
  Constant expressions shall not contain assignment, increment, decrement, function-call,
  or comma operators, except when they are contained within a subexpression that is not
  evaluated.<sup><a href="#note98"><b>98)</b></a></sup>
-<p><!--para 4 -->
+<p><a name="6.6p4" href="#6.6p4"><small>4</small></a>
  Each constant expression shall evaluate to a constant that is in the range of representable
  values for its type.
 <p><b>Semantics</b>
-<p><!--para 5 -->
+<p><a name="6.6p5" href="#6.6p5"><small>5</small></a>
  An expression that evaluates to a constant is required in several contexts. If a floating
  expression is evaluated in the translation environment, the arithmetic precision and range
  shall be at least as great as if the expression were being evaluated in the execution
  environment.
-<p><!--para 6 -->
+<p><a name="6.6p6" href="#6.6p6"><small>6</small></a>
  An integer constant expression<sup><a href="#note99"><b>99)</b></a></sup> shall have integer type and shall only have operands
  that are integer constants, enumeration constants, character constants, sizeof
  expressions whose results are integer constants, and floating constants that are the
  immediate operands of casts. Cast operators in an integer constant expression shall only
  convert arithmetic types to integer types, except as part of an operand to the sizeof
  operator.
-<p><!--para 7 -->
+<p><a name="6.6p7" href="#6.6p7"><small>7</small></a>
  More latitude is permitted for constant expressions in initializers. Such a constant
  expression shall be, or evaluate to, one of the following:
 <ul>
@@ -5267,13 +5267,13 @@ unsigned long long int
 <li>  an address constant, or
 <li>  an address constant for an object type plus or minus an integer constant expression.
 </ul>
-<p><!--para 8 -->
+<p><a name="6.6p8" href="#6.6p8"><small>8</small></a>
  An arithmetic constant expression shall have arithmetic type and shall only have
  operands that are integer constants, floating constants, enumeration constants, character
  constants, and sizeof expressions. Cast operators in an arithmetic constant expression
  shall only convert arithmetic types to arithmetic types, except as part of an operand to a
  sizeof operator whose result is an integer constant.
-<p><!--para 9 -->
+<p><a name="6.6p9" href="#6.6p9"><small>9</small></a>
  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
@@ -5281,9 +5281,9 @@ unsigned long long int
  and -&gt; operators, the address &amp; and indirection * unary operators, and pointer casts may
  be used in the creation of an address constant, but the value of an object shall not be
  accessed by use of these operators.
-<p><!--para 10 -->
+<p><a name="6.6p10" href="#6.6p10"><small>10</small></a>
  An implementation may accept other forms of constant expressions.
-<p><!--para 11 -->
+<p><a name="6.6p11" href="#6.6p11"><small>11</small></a>
  The semantic rules for the evaluation of a constant expression are the same as for
  nonconstant expressions.<sup><a href="#note100"><b>100)</b></a></sup>
 <p><b> Forward references</b>: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), initialization (<a href="#6.7.8">6.7.8</a>).
@@ -5312,7 +5312,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.7" href="#6.7">6.7 Declarations</a></h3>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7p1" href="#6.7p1"><small>1</small></a>
 <pre>
           declaration:
                  declaration-specifiers init-declarator-list<sub>opt</sub> ;
@@ -5329,18 +5329,18 @@ unsigned long long int
                   declarator = initializer
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7p2" href="#6.7p2"><small>2</small></a>
  A declaration shall declare at least a declarator (other than the parameters of a function or
  the members of a structure or union), a tag, or the members of an enumeration.
-<p><!--para 3 -->
+<p><a name="6.7p3" href="#6.7p3"><small>3</small></a>
  If an identifier has no linkage, there shall be no more than one declaration of the identifier
  (in a declarator or type specifier) with the same scope and in the same name space, except
  for tags as specified in <a href="#6.7.2.3">6.7.2.3</a>.
-<p><!--para 4 -->
+<p><a name="6.7p4" href="#6.7p4"><small>4</small></a>
  All declarations in the same scope that refer to the same object or function shall specify
  compatible types.
 <p><b>Semantics</b>
-<p><!--para 5 -->
+<p><a name="6.7p5" href="#6.7p5"><small>5</small></a>
  A declaration specifies the interpretation and attributes of a set of identifiers. A definition
  of an identifier is a declaration for that identifier that:
 <ul>
@@ -5349,7 +5349,7 @@ unsigned long long int
 <li>  for an enumeration constant or typedef name, is the (only) declaration of the
  identifier.
 </ul>
-<p><!--para 6 -->
+<p><a name="6.7p6" href="#6.7p6"><small>6</small></a>
  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
@@ -5357,7 +5357,7 @@ unsigned long long int
 <!--page 110 -->
  additional type information, or an initializer, or both. The declarators contain the
  identifiers (if any) being declared.
-<p><!--para 7 -->
+<p><a name="6.7p7" href="#6.7p7"><small>7</small></a>
  If an identifier for an object is declared with no linkage, the type for the object shall be
  complete by the end of its declarator, or by the end of its init-declarator if it has an
  initializer; in the case of function parameters (including in prototypes), it is the adjusted
@@ -5372,7 +5372,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.1" href="#6.7.1">6.7.1 Storage-class specifiers</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.1p1" href="#6.7.1p1"><small>1</small></a>
 <pre>
           storage-class-specifier:
                  typedef
@@ -5382,26 +5382,26 @@ unsigned long long int
                  register
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.1p2" href="#6.7.1p2"><small>2</small></a>
  At most, one storage-class specifier may be given in the declaration specifiers in a
  declaration.<sup><a href="#note102"><b>102)</b></a></sup>
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.7.1p3" href="#6.7.1p3"><small>3</small></a>
  The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
  only; it is discussed in <a href="#6.7.7">6.7.7</a>. The meanings of the various linkages and storage durations
  were discussed in <a href="#6.2.2">6.2.2</a> and <a href="#6.2.4">6.2.4</a>.
-<p><!--para 4 -->
+<p><a name="6.7.1p4" href="#6.7.1p4"><small>4</small></a>
  A declaration of an identifier for an object with storage-class specifier register
  suggests that access to the object be as fast as possible. The extent to which such
  suggestions are effective is implementation-defined.<sup><a href="#note103"><b>103)</b></a></sup>
-<p><!--para 5 -->
+<p><a name="6.7.1p5" href="#6.7.1p5"><small>5</small></a>
  The declaration of an identifier for a function that has block scope shall have no explicit
  storage-class specifier other than extern.
  
  
  
 <!--page 111 -->
-<p><!--para 6 -->
+<p><a name="6.7.1p6" href="#6.7.1p6"><small>6</small></a>
  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
@@ -5422,7 +5422,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.2" href="#6.7.2">6.7.2 Type specifiers</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.2p1" href="#6.7.2p1"><small>1</small></a>
 <pre>
           type-specifier:
                  void
@@ -5441,7 +5441,7 @@ unsigned long long int
                  typedef-name
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.2p2" href="#6.7.2p2"><small>2</small></a>
  At least one type specifier shall be given in the declaration specifiers in each declaration,
  and in the specifier-qualifier list in each struct declaration and type name. Each list of
  type specifiers shall be one of the following sets (delimited by commas, when there is
@@ -5473,15 +5473,15 @@ unsigned long long int
 <li>  enum specifier
 <li>  typedef name
 </ul>
-<p><!--para 3 -->
+<p><a name="6.7.2p3" href="#6.7.2p3"><small>3</small></a>
  The type specifier _Complex shall not be used if the implementation does not provide
  complex types.<sup><a href="#note104"><b>104)</b></a></sup>
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.7.2p4" href="#6.7.2p4"><small>4</small></a>
  Specifiers for structures, unions, and enumerations are discussed in <a href="#6.7.2.1">6.7.2.1</a> through
  <a href="#6.7.2.3">6.7.2.3</a>. Declarations of typedef names are discussed in <a href="#6.7.7">6.7.7</a>. The characteristics of the
  other types are discussed in <a href="#6.2.5">6.2.5</a>.
-<p><!--para 5 -->
+<p><a name="6.7.2p5" href="#6.7.2p5"><small>5</small></a>
  Each of the comma-separated sets designates the same type, except that for bit-fields, it is
  implementation-defined whether the specifier int designates the same type as signed
  int or the same type as unsigned int.
@@ -5500,7 +5500,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.7.2.1" href="#6.7.2.1">6.7.2.1 Structure and union specifiers</a></h5>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.2.1p1" href="#6.7.2.1p1"><small>1</small></a>
 <pre>
           struct-or-union-specifier:
                   struct-or-union identifier<sub>opt</sub> { struct-declaration-list }
@@ -5524,46 +5524,46 @@ unsigned long long int
                   declarator<sub>opt</sub> : constant-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.2.1p2" href="#6.7.2.1p2"><small>2</small></a>
  A structure or union shall not contain a member with incomplete or function type (hence,
  a structure shall not contain an instance of itself, but may contain a pointer to an instance
  of itself), except that the last member of a structure with more than one named member
  may have incomplete array type; such a structure (and any union containing, possibly
  recursively, a member that is such a structure) shall not be a member of a structure or an
  element of an array.
-<p><!--para 3 -->
+<p><a name="6.7.2.1p3" href="#6.7.2.1p3"><small>3</small></a>
  The expression that specifies the width of a bit-field shall be an integer constant
  expression with a nonnegative value that does not exceed the width of an object of the
  type that would be specified were the colon and expression omitted. If the value is zero,
  the declaration shall have no declarator.
-<p><!--para 4 -->
+<p><a name="6.7.2.1p4" href="#6.7.2.1p4"><small>4</small></a>
  A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
  int, unsigned int, or some other implementation-defined type.
 <!--page 114 -->
 <p><b>Semantics</b>
-<p><!--para 5 -->
+<p><a name="6.7.2.1p5" href="#6.7.2.1p5"><small>5</small></a>
  As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
  storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
  of members whose storage overlap.
-<p><!--para 6 -->
+<p><a name="6.7.2.1p6" href="#6.7.2.1p6"><small>6</small></a>
  Structure and union specifiers have the same form. The keywords struct and union
  indicate that the type being specified is, respectively, a structure type or a union type.
-<p><!--para 7 -->
+<p><a name="6.7.2.1p7" href="#6.7.2.1p7"><small>7</small></a>
  The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
  within a translation unit. The struct-declaration-list is a sequence of declarations for the
  members of the structure or union. If the struct-declaration-list contains no named
  members, the behavior is undefined. The type is incomplete until after the } that
  terminates the list.
-<p><!--para 8 -->
+<p><a name="6.7.2.1p8" href="#6.7.2.1p8"><small>8</small></a>
  A member of a structure or union may have any object type other than a variably
  modified type.<sup><a href="#note105"><b>105)</b></a></sup> In addition, a member may be declared to consist of a specified
  number of bits (including a sign bit, if any). Such a member is called a bit-field;<sup><a href="#note106"><b>106)</b></a></sup> its
  width is preceded by a colon.
-<p><!--para 9 -->
+<p><a name="6.7.2.1p9" href="#6.7.2.1p9"><small>9</small></a>
  A bit-field is interpreted as a signed or unsigned integer type consisting of the specified
  number of bits.<sup><a href="#note107"><b>107)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of type
  _Bool, the value of the bit-field shall compare equal to the value stored.
-<p><!--para 10 -->
+<p><a name="6.7.2.1p10" href="#6.7.2.1p10"><small>10</small></a>
  An implementation may allocate any addressable storage unit large enough to hold a bit-
  field. If enough space remains, a bit-field that immediately follows another bit-field in a
  structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
@@ -5571,7 +5571,7 @@ unsigned long long int
  implementation-defined. The order of allocation of bit-fields within a unit (high-order to
  low-order or low-order to high-order) is implementation-defined. The alignment of the
  addressable storage unit is unspecified.
-<p><!--para 11 -->
+<p><a name="6.7.2.1p11" href="#6.7.2.1p11"><small>11</small></a>
  A bit-field declaration with no declarator, but only a colon and a width, indicates an
  unnamed bit-field.<sup><a href="#note108"><b>108)</b></a></sup> As a special case, a bit-field structure member with a width of 0
  indicates that no further bit-field is to be packed into the unit in which the previous bit-
@@ -5579,23 +5579,23 @@ unsigned long long int
  
  
 <!--page 115 -->
-<p><!--para 12 -->
+<p><a name="6.7.2.1p12" href="#6.7.2.1p12"><small>12</small></a>
  Each non-bit-field member of a structure or union object is aligned in an implementation-
  defined manner appropriate to its type.
-<p><!--para 13 -->
+<p><a name="6.7.2.1p13" href="#6.7.2.1p13"><small>13</small></a>
  Within a structure object, the non-bit-field members and the units in which bit-fields
  reside have addresses that increase in the order in which they are declared. A pointer to a
  structure object, suitably converted, points to its initial member (or if that member is a
  bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
  padding within a structure object, but not at its beginning.
-<p><!--para 14 -->
+<p><a name="6.7.2.1p14" href="#6.7.2.1p14"><small>14</small></a>
  The size of a union is sufficient to contain the largest of its members. The value of at
  most one of the members can be stored in a union object at any time. A pointer to a
  union object, suitably converted, points to each of its members (or if a member is a bit-
  field, then to the unit in which it resides), and vice versa.
-<p><!--para 15 -->
+<p><a name="6.7.2.1p15" href="#6.7.2.1p15"><small>15</small></a>
  There may be unnamed padding at the end of a structure or union.
-<p><!--para 16 -->
+<p><a name="6.7.2.1p16" href="#6.7.2.1p16"><small>16</small></a>
  As a special case, the last element of a structure with more than one named member may
  have an incomplete array type; this is called a flexible array member. In most situations,
  the flexible array member is ignored. In particular, the size of the structure is as if the
@@ -5608,7 +5608,7 @@ unsigned long long int
  from that of the replacement array. If this array would have no elements, it behaves as if
  it had one element but the behavior is undefined if any attempt is made to access that
  element or to generate a pointer one past it.
-<p><!--para 17 -->
+<p><a name="6.7.2.1p17" href="#6.7.2.1p17"><small>17</small></a>
  EXAMPLE       After the declaration:
 <pre>
          struct s { int n; double d[]; };
@@ -5625,7 +5625,7 @@ unsigned long long int
 </pre>
  (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
  not be the same).
-<p><!--para 18 -->
+<p><a name="6.7.2.1p18" href="#6.7.2.1p18"><small>18</small></a>
  Following the above declaration:
 <!--page 116 -->
 <pre>
@@ -5641,7 +5641,7 @@ unsigned long long int
 </pre>
  in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
  code.
-<p><!--para 19 -->
+<p><a name="6.7.2.1p19" href="#6.7.2.1p19"><small>19</small></a>
  After the further declaration:
 <pre>
           struct ss { int n; };
@@ -5652,7 +5652,7 @@ unsigned long long int
           sizeof (struct s) &gt;= offsetof(struct s, d)
 </pre>
  are always equal to 1.
-<p><!--para 20 -->
+<p><a name="6.7.2.1p20" href="#6.7.2.1p20"><small>20</small></a>
  If sizeof (double) is 8, then after the following code is executed:
 <pre>
           struct s *s1;
@@ -5666,7 +5666,7 @@ unsigned long long int
           struct { int n; double d[8]; } *s1;
           struct { int n; double d[5]; } *s2;
 </pre>
-<p><!--para 21 -->
+<p><a name="6.7.2.1p21" href="#6.7.2.1p21"><small>21</small></a>
  Following the further successful assignments:
 <pre>
           s1 = malloc(sizeof (struct s) + 10);
@@ -5684,7 +5684,7 @@ unsigned long long int
           dp = &amp;(s2-&gt;d[0]);           //   valid
           *dp = 42;                   //   undefined behavior
 </pre>
-<p><!--para 22 -->
+<p><a name="6.7.2.1p22" href="#6.7.2.1p22"><small>22</small></a>
  The assignment:
 <pre>
           *s1 = *s2;
@@ -5712,7 +5712,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.7.2.2" href="#6.7.2.2">6.7.2.2 Enumeration specifiers</a></h5>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.2.2p1" href="#6.7.2.2p1"><small>1</small></a>
 <pre>
           enum-specifier:
                 enum identifier<sub>opt</sub> { enumerator-list }
@@ -5726,11 +5726,11 @@ unsigned long long int
                 enumeration-constant = constant-expression
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.2.2p2" href="#6.7.2.2p2"><small>2</small></a>
  The expression that defines the value of an enumeration constant shall be an integer
  constant expression that has a value representable as an int.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.7.2.2p3" href="#6.7.2.2p3"><small>3</small></a>
  The identifiers in an enumerator list are declared as constants that have type int and
  may appear wherever such are permitted.<sup><a href="#note109"><b>109)</b></a></sup> An enumerator with = defines its
  enumeration constant as the value of the constant expression. If the first enumerator has
@@ -5739,7 +5739,7 @@ unsigned long long int
  adding 1 to the value of the previous enumeration constant. (The use of enumerators with
  = may produce enumeration constants with values that duplicate other values in the same
  enumeration.) The enumerators of an enumeration are also known as its members.
-<p><!--para 4 -->
+<p><a name="6.7.2.2p4" href="#6.7.2.2p4"><small>4</small></a>
  Each enumerated type shall be compatible with char, a signed integer type, or an
  unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note110"><b>110)</b></a></sup> but shall be
  capable of representing the values of all the members of the enumeration. The
@@ -5750,7 +5750,7 @@ unsigned long long int
  
  
 <!--page 118 -->
-<p><!--para 5 -->
+<p><a name="6.7.2.2p5" href="#6.7.2.2p5"><small>5</small></a>
  EXAMPLE       The following fragment:
 <pre>
          enum hue { chartreuse, burgundy, claret=20, winedark };
@@ -5776,27 +5776,27 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.7.2.3" href="#6.7.2.3">6.7.2.3 Tags</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.7.2.3p1" href="#6.7.2.3p1"><small>1</small></a>
  A specific type shall have its content defined at most once.
-<p><!--para 2 -->
+<p><a name="6.7.2.3p2" href="#6.7.2.3p2"><small>2</small></a>
  Where two declarations that use the same tag declare the same type, they shall both use
  the same choice of struct, union, or enum.
-<p><!--para 3 -->
+<p><a name="6.7.2.3p3" href="#6.7.2.3p3"><small>3</small></a>
  A type specifier of the form
 <pre>
          enum identifier
 </pre>
  without an enumerator list shall only appear after the type it specifies is complete.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.7.2.3p4" href="#6.7.2.3p4"><small>4</small></a>
  All declarations of structure, union, or enumerated types that have the same scope and
  use the same tag declare the same type. The type is incomplete<sup><a href="#note111"><b>111)</b></a></sup> until the closing brace
  of the list defining the content, and complete thereafter.
-<p><!--para 5 -->
+<p><a name="6.7.2.3p5" href="#6.7.2.3p5"><small>5</small></a>
  Two declarations of structure, union, or enumerated types which are in different scopes or
  use different tags declare distinct types. Each declaration of a structure, union, or
  enumerated type which does not include a tag declares a distinct type.
-<p><!--para 6 -->
+<p><a name="6.7.2.3p6" href="#6.7.2.3p6"><small>6</small></a>
  A type specifier of the form
 <pre>
          struct-or-union identifier<sub>opt</sub> { struct-declaration-list }
@@ -5814,13 +5814,13 @@ unsigned long long int
 <!--page 119 -->
  union content, or enumeration content. If an identifier is provided,<sup><a href="#note112"><b>112)</b></a></sup> the type specifier
  also declares the identifier to be the tag of that type.
-<p><!--para 7 -->
+<p><a name="6.7.2.3p7" href="#6.7.2.3p7"><small>7</small></a>
  A declaration of the form
 <pre>
           struct-or-union identifier ;
 </pre>
  specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note113"><b>113)</b></a></sup>
-<p><!--para 8 -->
+<p><a name="6.7.2.3p8" href="#6.7.2.3p8"><small>8</small></a>
  If a type specifier of the form
 <pre>
           struct-or-union identifier
@@ -5828,7 +5828,7 @@ unsigned long long int
  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.<sup><a href="#note113"><b>113)</b></a></sup>
-<p><!--para 9 -->
+<p><a name="6.7.2.3p9" href="#6.7.2.3p9"><small>9</small></a>
  If a type specifier of the form
 <pre>
           struct-or-union identifier
@@ -5840,7 +5840,7 @@ unsigned long long int
  occurs other than as part of one of the above forms, and a declaration of the identifier as a
  tag is visible, then it specifies the same type as that other declaration, and does not
  redeclare the tag.
-<p><!--para 10 -->
+<p><a name="6.7.2.3p10" href="#6.7.2.3p10"><small>10</small></a>
  EXAMPLE 1       This mechanism allows declaration of a self-referential structure.
 <pre>
           struct tnode {
@@ -5857,7 +5857,7 @@ unsigned long long int
  these declarations, the expression sp-&gt;left refers to the left struct tnode pointer of the object to
  which sp points; the expression s.right-&gt;count designates the count member of the right struct
  tnode pointed to from s.
-<p><!--para 11 -->
+<p><a name="6.7.2.3p11" href="#6.7.2.3p11"><small>11</small></a>
  The following alternative formulation uses the typedef mechanism:
  
  
@@ -5873,7 +5873,7 @@ unsigned long long int
           TNODE s, *sp;
 </pre>
  
-<p><!--para 12 -->
+<p><a name="6.7.2.3p12" href="#6.7.2.3p12"><small>12</small></a>
  EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
  structures, the declarations
 <pre>
@@ -5909,7 +5909,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.3" href="#6.7.3">6.7.3 Type qualifiers</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.3p1" href="#6.7.3p1"><small>1</small></a>
 <pre>
           type-qualifier:
                  const
@@ -5917,14 +5917,14 @@ unsigned long long int
                  volatile
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.3p2" href="#6.7.3p2"><small>2</small></a>
  Types other than pointer types derived from object or incomplete types shall not be
  restrict-qualified.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.7.3p3" href="#6.7.3p3"><small>3</small></a>
  The properties associated with qualified types are meaningful only for expressions that
  are lvalues.<sup><a href="#note114"><b>114)</b></a></sup>
-<p><!--para 4 -->
+<p><a name="6.7.3p4" href="#6.7.3p4"><small>4</small></a>
  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.
@@ -5933,12 +5933,12 @@ unsigned long long int
  
  
 <!--page 121 -->
-<p><!--para 5 -->
+<p><a name="6.7.3p5" href="#6.7.3p5"><small>5</small></a>
  If an attempt is made to modify an object defined with a const-qualified type through use
  of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
  made to refer to an object defined with a volatile-qualified type through use of an lvalue
  with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note115"><b>115)</b></a></sup>
-<p><!--para 6 -->
+<p><a name="6.7.3p6" href="#6.7.3p6"><small>6</small></a>
  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,
@@ -5946,7 +5946,7 @@ unsigned long long int
  object shall agree with that prescribed by the abstract machine, except as modified by the
  unknown factors mentioned previously.<sup><a href="#note116"><b>116)</b></a></sup> What constitutes an access to an object that
  has volatile-qualified type is implementation-defined.
-<p><!--para 7 -->
+<p><a name="6.7.3p7" href="#6.7.3p7"><small>7</small></a>
  An object that is accessed through a restrict-qualified pointer has a special association
  with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
  that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note117"><b>117)</b></a></sup> The intended
@@ -5954,15 +5954,15 @@ unsigned long long int
  optimization, and deleting all instances of the qualifier from all preprocessing translation
  units composing a conforming program does not change its meaning (i.e., observable
  behavior).
-<p><!--para 8 -->
+<p><a name="6.7.3p8" href="#6.7.3p8"><small>8</small></a>
  If the specification of an array type includes any type qualifiers, the element type is so-
  qualified, not the array type. If the specification of a function type includes any type
  qualifiers, the behavior is undefined.<sup><a href="#note118"><b>118)</b></a></sup>
-<p><!--para 9 -->
+<p><a name="6.7.3p9" href="#6.7.3p9"><small>9</small></a>
  For two qualified types to be compatible, both shall have the identically qualified version
  of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
  does not affect the specified type.
-<p><!--para 10 -->
+<p><a name="6.7.3p10" href="#6.7.3p10"><small>10</small></a>
  EXAMPLE 1       An object declared
 <pre>
           extern const volatile int real_time_clock;
@@ -5973,7 +5973,7 @@ unsigned long long int
  
  
 <!--page 122 -->
-<p><!--para 11 -->
+<p><a name="6.7.3p11" href="#6.7.3p11"><small>11</small></a>
  EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
  modify an aggregate type:
 <pre>
@@ -6014,20 +6014,20 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.7.3.1" href="#6.7.3.1">6.7.3.1 Formal definition of restrict</a></h5>
-<p><!--para 1 -->
+<p><a name="6.7.3.1p1" href="#6.7.3.1p1"><small>1</small></a>
  Let D be a declaration of an ordinary identifier that provides a means of designating an
  object P as a restrict-qualified pointer to type T.
-<p><!--para 2 -->
+<p><a name="6.7.3.1p2" href="#6.7.3.1p2"><small>2</small></a>
  If D appears inside a block and does not have storage class extern, let B denote the
  block. If D appears in the list of parameter declarations of a function definition, let B
  denote the associated block. Otherwise, let B denote the block of main (or the block of
  whatever function is called at program startup in a freestanding environment).
-<p><!--para 3 -->
+<p><a name="6.7.3.1p3" href="#6.7.3.1p3"><small>3</small></a>
  In what follows, a pointer expression E is said to be based on object P if (at some
  sequence point in the execution of B prior to the evaluation of E) modifying P to point to
  a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note119"><b>119)</b></a></sup>
  Note that ''based'' is defined only for expressions with pointer types.
-<p><!--para 4 -->
+<p><a name="6.7.3.1p4" href="#6.7.3.1p4"><small>4</small></a>
  During each execution of B, let L be any lvalue that has &amp;L based on P. If L is used to
  access the value of the object X that it designates, and X is also modified (by any means),
  then the following requirements apply: T shall not be const-qualified. Every other lvalue
@@ -6037,15 +6037,15 @@ unsigned long long int
  object P2, associated with block B2, then either the execution of B2 shall begin before
  the execution of B, or the execution of B2 shall end prior to the assignment. If these
  requirements are not met, then the behavior is undefined.
-<p><!--para 5 -->
+<p><a name="6.7.3.1p5" href="#6.7.3.1p5"><small>5</small></a>
  Here an execution of B means that portion of the execution of the program that would
  correspond to the lifetime of an object with scalar type and automatic storage duration
  
 <!--page 123 -->
  associated with B.
-<p><!--para 6 -->
+<p><a name="6.7.3.1p6" href="#6.7.3.1p6"><small>6</small></a>
  A translator is free to ignore any or all aliasing implications of uses of restrict.
-<p><!--para 7 -->
+<p><a name="6.7.3.1p7" href="#6.7.3.1p7"><small>7</small></a>
  EXAMPLE 1       The file scope declarations
 <pre>
           int * restrict a;
@@ -6055,7 +6055,7 @@ unsigned long long int
  assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
  program, then it is never accessed using either of the other two.
  
-<p><!--para 8 -->
+<p><a name="6.7.3.1p8" href="#6.7.3.1p8"><small>8</small></a>
  EXAMPLE 2 The function parameter declarations in the following example
 <pre>
          void f(int n, int * restrict p, int * restrict q)
@@ -6066,7 +6066,7 @@ unsigned long long int
 </pre>
  assert that, during each execution of the function, if an object is accessed through one of the pointer
  parameters, then it is not also accessed through the other.
-<p><!--para 9 -->
+<p><a name="6.7.3.1p9" href="#6.7.3.1p9"><small>9</small></a>
  The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
  analysis of function f without examining any of the calls of f in the program. The cost is that the
  programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
@@ -6081,7 +6081,7 @@ unsigned long long int
          }
 </pre>
  
-<p><!--para 10 -->
+<p><a name="6.7.3.1p10" href="#6.7.3.1p10"><small>10</small></a>
  EXAMPLE 3       The function parameter declarations
 <pre>
          void h(int n, int * restrict p, int * restrict q, int * restrict r)
@@ -6095,7 +6095,7 @@ unsigned long long int
  are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
  modified within function h.
  
-<p><!--para 11 -->
+<p><a name="6.7.3.1p11" href="#6.7.3.1p11"><small>11</small></a>
  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.
@@ -6113,7 +6113,7 @@ unsigned long long int
                    }
           }
 </pre>
-<p><!--para 12 -->
+<p><a name="6.7.3.1p12" href="#6.7.3.1p12"><small>12</small></a>
  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.
@@ -6139,29 +6139,29 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.4" href="#6.7.4">6.7.4 Function specifiers</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.4p1" href="#6.7.4p1"><small>1</small></a>
 <pre>
           function-specifier:
                  inline
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.4p2" href="#6.7.4p2"><small>2</small></a>
  Function specifiers shall be used only in the declaration of an identifier for a function.
-<p><!--para 3 -->
+<p><a name="6.7.4p3" href="#6.7.4p3"><small>3</small></a>
  An inline definition of a function with external linkage shall not contain a definition of a
  modifiable object with static storage duration, and shall not contain a reference to an
  identifier with internal linkage.
-<p><!--para 4 -->
+<p><a name="6.7.4p4" href="#6.7.4p4"><small>4</small></a>
  In a hosted environment, the inline function specifier shall not appear in a declaration
  of main.
 <p><b>Semantics</b>
-<p><!--para 5 -->
+<p><a name="6.7.4p5" href="#6.7.4p5"><small>5</small></a>
  A function declared with an inline function specifier is an inline function. The
  function specifier may appear more than once; the behavior is the same as if it appeared
  only once. Making a function an inline function suggests that calls to the function be as
  fast as possible.<sup><a href="#note120"><b>120)</b></a></sup> The extent to which such suggestions are effective is
  implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
-<p><!--para 6 -->
+<p><a name="6.7.4p6" href="#6.7.4p6"><small>6</small></a>
  Any function with internal linkage can be an inline function. For a function with external
  linkage, the following restrictions apply: If a function is declared with an inline
 <!--page 125 -->
@@ -6173,7 +6173,7 @@ unsigned long long int
  provides an alternative to an external definition, which a translator may use to implement
  any call to the function in the same translation unit. It is unspecified whether a call to the
  function uses the inline definition or the external definition.<sup><a href="#note122"><b>122)</b></a></sup>
-<p><!--para 7 -->
+<p><a name="6.7.4p7" href="#6.7.4p7"><small>7</small></a>
  EXAMPLE The declaration of an inline function with external linkage can result in either an external
  definition, or a definition available for use only within the translation unit. A file scope declaration with
  extern creates an external definition. The following example shows an entire translation unit.
@@ -6193,7 +6193,7 @@ unsigned long long int
                 return is_fahr ? cels(temp) : fahr(temp);
           }
 </pre>
-<p><!--para 8 -->
+<p><a name="6.7.4p8" href="#6.7.4p8"><small>8</small></a>
  Note that the definition of fahr is an external definition because fahr is also declared with extern, but
  the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
  external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
@@ -6224,7 +6224,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.5" href="#6.7.5">6.7.5 Declarators</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.5p1" href="#6.7.5p1"><small>1</small></a>
 <pre>
           declarator:
                  pointer<sub>opt</sub> direct-declarator
@@ -6257,18 +6257,18 @@ unsigned long long int
                   identifier-list , identifier
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.7.5p2" href="#6.7.5p2"><small>2</small></a>
  Each declarator declares one identifier, and asserts that when an operand of the same
  form as the declarator appears in an expression, it designates a function or object with the
  scope, storage duration, and type indicated by the declaration specifiers.
-<p><!--para 3 -->
+<p><a name="6.7.5p3" href="#6.7.5p3"><small>3</small></a>
  A full declarator is a declarator that is not part of another declarator. The end of a full
  declarator is a sequence point. If, in the nested sequence of declarators in a full
 <!--page 127 -->
  declarator, there is a declarator specifying a variable length array type, the type specified
  by the full declarator is said to be variably modified. Furthermore, any type derived by
  declarator type derivation from a variably modified type is itself variably modified.
-<p><!--para 4 -->
+<p><a name="6.7.5p4" href="#6.7.5p4"><small>4</small></a>
  In the following subclauses, consider a declaration
 <pre>
          T D1
@@ -6276,13 +6276,13 @@ unsigned long long int
  where T contains the declaration specifiers that specify a type T (such as int) and D1 is
  a declarator that contains an identifier ident. The type specified for the identifier ident in
  the various forms of declarator is described inductively using this notation.
-<p><!--para 5 -->
+<p><a name="6.7.5p5" href="#6.7.5p5"><small>5</small></a>
  If, in the declaration ''T D1'', D1 has the form
 <pre>
          identifier
 </pre>
  then the type specified for ident is T .
-<p><!--para 6 -->
+<p><a name="6.7.5p6" href="#6.7.5p6"><small>6</small></a>
  If, in the declaration ''T D1'', D1 has the form
 <pre>
          ( D )
@@ -6291,7 +6291,7 @@ unsigned long long int
  parentheses is identical to the unparenthesized declarator, but the binding of complicated
  declarators may be altered by parentheses.
 <p><b>Implementation limits</b>
-<p><!--para 7 -->
+<p><a name="6.7.5p7" href="#6.7.5p7"><small>7</small></a>
  As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
  function declarators that modify an arithmetic, structure, union, or incomplete type, either
  directly or via one or more typedefs.
@@ -6300,7 +6300,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.7.5.1" href="#6.7.5.1">6.7.5.1 Pointer declarators</a></h5>
 <p><b>Semantics</b>
-<p><!--para 1 -->
+<p><a name="6.7.5.1p1" href="#6.7.5.1p1"><small>1</small></a>
  If, in the declaration ''T D1'', D1 has the form
 <pre>
          * type-qualifier-list<sub>opt</sub> D
@@ -6308,10 +6308,10 @@ unsigned long long int
  and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
  T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
  pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
-<p><!--para 2 -->
+<p><a name="6.7.5.1p2" href="#6.7.5.1p2"><small>2</small></a>
  For two pointer types to be compatible, both shall be identically qualified and both shall
  be pointers to compatible types.
-<p><!--para 3 -->
+<p><a name="6.7.5.1p3" href="#6.7.5.1p3"><small>3</small></a>
  EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
  to a constant value'' and a ''constant pointer to a variable value''.
 <!--page 128 -->
@@ -6323,7 +6323,7 @@ unsigned long long int
  but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
  int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
  same location.
-<p><!--para 4 -->
+<p><a name="6.7.5.1p4" href="#6.7.5.1p4"><small>4</small></a>
  The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
  type ''pointer to int''.
 <pre>
@@ -6336,7 +6336,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.7.5.2" href="#6.7.5.2">6.7.5.2 Array declarators</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.7.5.2p1" href="#6.7.5.2p1"><small>1</small></a>
  In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
  an expression or *. If they delimit an expression (which specifies the size of an array), the
  expression shall have an integer type. If the expression is a constant expression, it shall
@@ -6344,12 +6344,12 @@ unsigned long long int
  type. The optional type qualifiers and the keyword static shall appear only in a
  declaration of a function parameter with an array type, and then only in the outermost
  array type derivation.
-<p><!--para 2 -->
+<p><a name="6.7.5.2p2" href="#6.7.5.2p2"><small>2</small></a>
  An ordinary identifier (as defined in <a href="#6.2.3">6.2.3</a>) that has a variably modified type shall have
  either block scope and no linkage or function prototype scope. If an identifier is declared
  to be an object with static storage duration, it shall not have a variable length array type.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.7.5.2p3" href="#6.7.5.2p3"><small>3</small></a>
  If, in the declaration ''T D1'', D1 has one of the forms:
 <pre>
           D[ type-qualifier-list<sub>opt</sub> assignment-expression<sub>opt</sub> ]
@@ -6360,7 +6360,7 @@ unsigned long long int
  and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
  T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note123"><b>123)</b></a></sup>
  (See <a href="#6.7.5.3">6.7.5.3</a> for the meaning of the optional type qualifiers and the keyword static.)
-<p><!--para 4 -->
+<p><a name="6.7.5.2p4" href="#6.7.5.2p4"><small>4</small></a>
  If the size is not present, the array type is an incomplete type. If the size is * instead of
  being an expression, the array type is a variable length array type of unspecified size,
  which can only be used in declarations with function prototype scope;<sup><a href="#note124"><b>124)</b></a></sup> such arrays are
@@ -6369,7 +6369,7 @@ unsigned long long int
 <!--page 129 -->
  type has a known constant size, the array type is not a variable length array type;
  otherwise, the array type is a variable length array type.
-<p><!--para 5 -->
+<p><a name="6.7.5.2p5" href="#6.7.5.2p5"><small>5</small></a>
  If the size is an expression that is not an integer constant expression: if it occurs in a
  declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
  each time it is evaluated it shall have a value greater than zero. The size of each instance
@@ -6377,20 +6377,20 @@ unsigned long long int
  expression is part of the operand of a sizeof operator and changing the value of the
  size expression would not affect the result of the operator, it is unspecified whether or not
  the size expression is evaluated.
-<p><!--para 6 -->
+<p><a name="6.7.5.2p6" href="#6.7.5.2p6"><small>6</small></a>
  For two array types to be compatible, both shall have compatible element types, and if
  both size specifiers are present, and are integer constant expressions, then both size
  specifiers shall have the same constant value. If the two array types are used in a context
  which requires them to be compatible, it is undefined behavior if the two size specifiers
  evaluate to unequal values.
-<p><!--para 7 -->
+<p><a name="6.7.5.2p7" href="#6.7.5.2p7"><small>7</small></a>
  EXAMPLE 1
 <pre>
           float fa[11], *afp[17];
 </pre>
  declares an array of float numbers and an array of pointers to float numbers.
  
-<p><!--para 8 -->
+<p><a name="6.7.5.2p8" href="#6.7.5.2p8"><small>8</small></a>
  EXAMPLE 2       Note the distinction between the declarations
 <pre>
           extern int *x;
@@ -6399,7 +6399,7 @@ unsigned long long int
  The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
  (an incomplete type), the storage for which is defined elsewhere.
  
-<p><!--para 9 -->
+<p><a name="6.7.5.2p9" href="#6.7.5.2p9"><small>9</small></a>
  EXAMPLE 3       The following declarations demonstrate the compatibility rules for variably modified types.
 <pre>
           extern int n;
@@ -6420,7 +6420,7 @@ unsigned long long int
  
  
 <!--page 130 -->
-<p><!--para 10 -->
+<p><a name="6.7.5.2p10" href="#6.7.5.2p10"><small>10</small></a>
  EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
  function prototype scope. Array objects declared with the static or extern storage-class specifier
  cannot have a variable length array (VLA) type. However, an object declared with the static storage-
@@ -6460,19 +6460,19 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.7.5.3" href="#6.7.5.3">6.7.5.3 Function declarators (including prototypes)</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.7.5.3p1" href="#6.7.5.3p1"><small>1</small></a>
  A function declarator shall not specify a return type that is a function type or an array
  type.
-<p><!--para 2 -->
+<p><a name="6.7.5.3p2" href="#6.7.5.3p2"><small>2</small></a>
  The only storage-class specifier that shall occur in a parameter declaration is register.
-<p><!--para 3 -->
+<p><a name="6.7.5.3p3" href="#6.7.5.3p3"><small>3</small></a>
  An identifier list in a function declarator that is not part of a definition of that function
  shall be empty.
-<p><!--para 4 -->
+<p><a name="6.7.5.3p4" href="#6.7.5.3p4"><small>4</small></a>
  After adjustment, the parameters in a parameter type list in a function declarator that is
  part of a definition of that function shall not have incomplete type.
 <p><b>Semantics</b>
-<p><!--para 5 -->
+<p><a name="6.7.5.3p5" href="#6.7.5.3p5"><small>5</small></a>
  If, in the declaration ''T D1'', D1 has the form
 <pre>
           D( parameter-type-list )
@@ -6485,43 +6485,43 @@ unsigned long long int
  and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
  T '', then the type specified for ident is ''derived-declarator-type-list function returning
  T ''.
-<p><!--para 6 -->
+<p><a name="6.7.5.3p6" href="#6.7.5.3p6"><small>6</small></a>
  A parameter type list specifies the types of, and may declare identifiers for, the
  parameters of the function.
-<p><!--para 7 -->
+<p><a name="6.7.5.3p7" href="#6.7.5.3p7"><small>7</small></a>
  A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
  type'', where the type qualifiers (if any) are those specified within the [ and ] of the
  array type derivation. If the keyword static also appears within the [ and ] of the
  array type derivation, then for each call to the function, the value of the corresponding
  actual argument shall provide access to the first element of an array with at least as many
  elements as specified by the size expression.
-<p><!--para 8 -->
+<p><a name="6.7.5.3p8" href="#6.7.5.3p8"><small>8</small></a>
  A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
  function returning type'', as in <a href="#6.3.2.1">6.3.2.1</a>.
-<p><!--para 9 -->
+<p><a name="6.7.5.3p9" href="#6.7.5.3p9"><small>9</small></a>
  If the list terminates with an ellipsis (, ...), no information about the number or types
  of the parameters after the comma is supplied.<sup><a href="#note125"><b>125)</b></a></sup>
-<p><!--para 10 -->
+<p><a name="6.7.5.3p10" href="#6.7.5.3p10"><small>10</small></a>
  The special case of an unnamed parameter of type void as the only item in the list
  specifies that the function has no parameters.
-<p><!--para 11 -->
+<p><a name="6.7.5.3p11" href="#6.7.5.3p11"><small>11</small></a>
  If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
  parameter name, it shall be taken as a typedef name.
-<p><!--para 12 -->
+<p><a name="6.7.5.3p12" href="#6.7.5.3p12"><small>12</small></a>
  If the function declarator is not part of a definition of that function, parameters may have
  incomplete type and may use the [*] notation in their sequences of declarator specifiers
  to specify variable length array types.
-<p><!--para 13 -->
+<p><a name="6.7.5.3p13" href="#6.7.5.3p13"><small>13</small></a>
  The storage-class specifier in the declaration specifiers for a parameter declaration, if
  present, is ignored unless the declared parameter is one of the members of the parameter
  type list for a function definition.
-<p><!--para 14 -->
+<p><a name="6.7.5.3p14" href="#6.7.5.3p14"><small>14</small></a>
  An identifier list declares only the identifiers of the parameters of the function. An empty
  list in a function declarator that is part of a definition of that function specifies that the
  function has no parameters. The empty list in a function declarator that is not part of a
  definition of that function specifies that no information about the number or types of the
  parameters is supplied.<sup><a href="#note126"><b>126)</b></a></sup>
-<p><!--para 15 -->
+<p><a name="6.7.5.3p15" href="#6.7.5.3p15"><small>15</small></a>
  For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note127"><b>127)</b></a></sup>
  
  
@@ -6540,7 +6540,7 @@ unsigned long long int
  compatibility and of a composite type, each parameter declared with function or array
  type is taken as having the adjusted type and each parameter declared with qualified type
  is taken as having the unqualified version of its declared type.)
-<p><!--para 16 -->
+<p><a name="6.7.5.3p16" href="#6.7.5.3p16"><small>16</small></a>
  EXAMPLE 1       The declaration
 <pre>
           int f(void), *fip(), (*pfi)();
@@ -6552,13 +6552,13 @@ unsigned long long int
  and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
  extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
  designator, which is then used to call the function; it returns an int.
-<p><!--para 17 -->
+<p><a name="6.7.5.3p17" href="#6.7.5.3p17"><small>17</small></a>
  If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
  declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
  internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
  the identifier of the pointer pfi has block scope and no linkage.
  
-<p><!--para 18 -->
+<p><a name="6.7.5.3p18" href="#6.7.5.3p18"><small>18</small></a>
  EXAMPLE 2       The declaration
 <pre>
           int (*apfi[3])(int *x, int *y);
@@ -6567,7 +6567,7 @@ unsigned long long int
  parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
  go out of scope at the end of the declaration of apfi.
  
-<p><!--para 19 -->
+<p><a name="6.7.5.3p19" href="#6.7.5.3p19"><small>19</small></a>
  EXAMPLE 3       The declaration
 <pre>
           int (*fpfi(int (*)(long), int))(int, ...);
@@ -6577,7 +6577,7 @@ unsigned long long int
  The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
  additional arguments of any type.
 <!--page 133 -->
-<p><!--para 20 -->
+<p><a name="6.7.5.3p20" href="#6.7.5.3p20"><small>20</small></a>
  EXAMPLE 4        The following prototype has a variably modified parameter.
 <pre>
            void addscalar(int n, int m,
@@ -6598,7 +6598,7 @@ unsigned long long int
            }
 </pre>
  
-<p><!--para 21 -->
+<p><a name="6.7.5.3p21" href="#6.7.5.3p21"><small>21</small></a>
  EXAMPLE 5        The following are all compatible function prototype declarators.
 <pre>
            double    maximum(int       n,   int   m,   double   a[n][m]);
@@ -6631,7 +6631,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.6" href="#6.7.6">6.7.6 Type names</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.6p1" href="#6.7.6p1"><small>1</small></a>
 <pre>
           type-name:
                  specifier-qualifier-list abstract-declarator<sub>opt</sub>
@@ -6650,11 +6650,11 @@ unsigned long long int
                   direct-abstract-declarator<sub>opt</sub> ( parameter-type-list<sub>opt</sub> )
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.7.6p2" href="#6.7.6p2"><small>2</small></a>
  In several contexts, it is necessary to specify a type. This is accomplished using a type
  name, which is syntactically a declaration for a function or an object of that type that
  omits the identifier.<sup><a href="#note128"><b>128)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.7.6p3" href="#6.7.6p3"><small>3</small></a>
  EXAMPLE        The constructions
 <pre>
           (a)      int
@@ -6686,16 +6686,16 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.7" href="#6.7.7">6.7.7 Type definitions</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.7p1" href="#6.7.7p1"><small>1</small></a>
 <pre>
           typedef-name:
                  identifier
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.7p2" href="#6.7.7p2"><small>2</small></a>
  If a typedef name specifies a variably modified type then it shall have block scope.
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.7.7p3" href="#6.7.7p3"><small>3</small></a>
  In a declaration whose storage-class specifier is typedef, each declarator defines an
  identifier to be a typedef name that denotes the type specified for the identifier in the way
  described in <a href="#6.7.5">6.7.5</a>. Any array size expressions associated with variable length array
@@ -6711,7 +6711,7 @@ unsigned long long int
  type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
  typedef name shares the same name space as other identifiers declared in ordinary
  declarators.
-<p><!--para 4 -->
+<p><a name="6.7.7p4" href="#6.7.7p4"><small>4</small></a>
  EXAMPLE 1       After
 <pre>
           typedef int MILES, KLICKSP();
@@ -6728,7 +6728,7 @@ unsigned long long int
  parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
  such a structure. The object distance has a type compatible with any other int object.
  
-<p><!--para 5 -->
+<p><a name="6.7.7p5" href="#6.7.7p5"><small>5</small></a>
  EXAMPLE 2       After the declarations
 <pre>
           typedef struct s1 { int x; } t1, *tp1;
@@ -6737,7 +6737,7 @@ unsigned long long int
  type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
  s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
 <!--page 136 -->
-<p><!--para 6 -->
+<p><a name="6.7.7p6" href="#6.7.7p6"><small>6</small></a>
  EXAMPLE 3       The following obscure constructions
 <pre>
          typedef signed int t;
@@ -6764,7 +6764,7 @@ unsigned long long int
  with type pointer to function returning signed int with one unnamed parameter with type signed
  int'', and an identifier t with type long int.
  
-<p><!--para 7 -->
+<p><a name="6.7.7p7" href="#6.7.7p7"><small>7</small></a>
  EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
  following declarations of the signal function specify exactly the same type, the first without making use
  of any typedef names.
@@ -6775,7 +6775,7 @@ unsigned long long int
          pfv signal(int, pfv);
 </pre>
  
-<p><!--para 8 -->
+<p><a name="6.7.7p8" href="#6.7.7p8"><small>8</small></a>
  EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
  time the typedef name is defined, not each time it is used:
 <!--page 137 -->
@@ -6794,7 +6794,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.7.8" href="#6.7.8">6.7.8 Initialization</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.7.8p1" href="#6.7.8p1"><small>1</small></a>
 <pre>
           initializer:
                    assignment-expression
@@ -6813,19 +6813,19 @@ unsigned long long int
                  . identifier
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.7.8p2" href="#6.7.8p2"><small>2</small></a>
  No initializer shall attempt to provide a value for an object not contained within the entity
  being initialized.
-<p><!--para 3 -->
+<p><a name="6.7.8p3" href="#6.7.8p3"><small>3</small></a>
  The type of the entity to be initialized shall be an array of unknown size or an object type
  that is not a variable length array type.
-<p><!--para 4 -->
+<p><a name="6.7.8p4" href="#6.7.8p4"><small>4</small></a>
  All the expressions in an initializer for an object that has static storage duration shall be
  constant expressions or string literals.
-<p><!--para 5 -->
+<p><a name="6.7.8p5" href="#6.7.8p5"><small>5</small></a>
  If the declaration of an identifier has block scope, and the identifier has external or
  internal linkage, the declaration shall have no initializer for the identifier.
-<p><!--para 6 -->
+<p><a name="6.7.8p6" href="#6.7.8p6"><small>6</small></a>
  If a designator has the form
 <pre>
           [ constant-expression ]
@@ -6833,7 +6833,7 @@ unsigned long long int
  then the current object (defined below) shall have array type and the expression shall be
  an integer constant expression. If the array is of unknown size, any nonnegative value is
  valid.
-<p><!--para 7 -->
+<p><a name="6.7.8p7" href="#6.7.8p7"><small>7</small></a>
  If a designator has the form
 <pre>
           . identifier
@@ -6842,13 +6842,13 @@ unsigned long long int
  identifier shall be the name of a member of that type.
 <!--page 138 -->
 <p><b>Semantics</b>
-<p><!--para 8 -->
+<p><a name="6.7.8p8" href="#6.7.8p8"><small>8</small></a>
  An initializer specifies the initial value stored in an object.
-<p><!--para 9 -->
+<p><a name="6.7.8p9" href="#6.7.8p9"><small>9</small></a>
  Except where explicitly stated otherwise, for the purposes of this subclause unnamed
  members of objects of structure and union type do not participate in initialization.
  Unnamed members of structure objects have indeterminate value even after initialization.
-<p><!--para 10 -->
+<p><a name="6.7.8p10" href="#6.7.8p10"><small>10</small></a>
  If an object that has automatic storage duration is not initialized explicitly, its value is
  indeterminate. If an object that has static storage duration is not initialized explicitly,
  then:
@@ -6859,33 +6859,33 @@ unsigned long long int
 <li>  if it is a union, the first named member is initialized (recursively) according to these
  rules.
 </ul>
-<p><!--para 11 -->
+<p><a name="6.7.8p11" href="#6.7.8p11"><small>11</small></a>
  The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
  initial value of the object is that of the expression (after conversion); the same type
  constraints and conversions as for simple assignment apply, taking the type of the scalar
  to be the unqualified version of its declared type.
-<p><!--para 12 -->
+<p><a name="6.7.8p12" href="#6.7.8p12"><small>12</small></a>
  The rest of this subclause deals with initializers for objects that have aggregate or union
  type.
-<p><!--para 13 -->
+<p><a name="6.7.8p13" href="#6.7.8p13"><small>13</small></a>
  The initializer for a structure or union object that has automatic storage duration shall be
  either an initializer list as described below, or a single expression that has compatible
  structure or union type. In the latter case, the initial value of the object, including
  unnamed members, is that of the expression.
-<p><!--para 14 -->
+<p><a name="6.7.8p14" href="#6.7.8p14"><small>14</small></a>
  An array of character type may be initialized by a character string literal, optionally
  enclosed in braces. Successive characters of the character string literal (including the
  terminating null character if there is room or if the array is of unknown size) initialize the
  elements of the array.
-<p><!--para 15 -->
+<p><a name="6.7.8p15" href="#6.7.8p15"><small>15</small></a>
  An array with element type compatible with wchar_t may be initialized by a wide
  string literal, optionally enclosed in braces. Successive wide characters of the wide string
  literal (including the terminating null wide character if there is room or if the array is of
  unknown size) initialize the elements of the array.
-<p><!--para 16 -->
+<p><a name="6.7.8p16" href="#6.7.8p16"><small>16</small></a>
  Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
  enclosed list of initializers for the elements or named members.
-<p><!--para 17 -->
+<p><a name="6.7.8p17" href="#6.7.8p17"><small>17</small></a>
  Each brace-enclosed initializer list has an associated current object. When no
  designations are present, subobjects of the current object are initialized in order according
  to the type of the current object: array elements in increasing subscript order, structure
@@ -6894,18 +6894,18 @@ unsigned long long int
  designation causes the following initializer to begin initialization of the subobject
  described by the designator. Initialization then continues forward in order, beginning
  with the next subobject after that described by the designator.<sup><a href="#note130"><b>130)</b></a></sup>
-<p><!--para 18 -->
+<p><a name="6.7.8p18" href="#6.7.8p18"><small>18</small></a>
  Each designator list begins its description with the current object associated with the
  closest surrounding brace pair. Each item in the designator list (in order) specifies a
  particular member of its current object and changes the current object for the next
  designator (if any) to be that member.<sup><a href="#note131"><b>131)</b></a></sup> The current object that results at the end of the
  designator list is the subobject to be initialized by the following initializer.
-<p><!--para 19 -->
+<p><a name="6.7.8p19" href="#6.7.8p19"><small>19</small></a>
  The initialization shall occur in initializer list order, each initializer provided for a
  particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note132"><b>132)</b></a></sup>
  all subobjects that are not initialized explicitly shall be initialized implicitly the same as
  objects that have static storage duration.
-<p><!--para 20 -->
+<p><a name="6.7.8p20" href="#6.7.8p20"><small>20</small></a>
  If the aggregate or union contains elements or members that are aggregates or unions,
  these rules apply recursively to the subaggregates or contained unions. If the initializer of
  a subaggregate or contained union begins with a left brace, the initializers enclosed by
@@ -6914,12 +6914,12 @@ unsigned long long int
  taken to account for the elements or members of the subaggregate or the first member of
  the contained union; any remaining initializers are left to initialize the next element or
  member of the aggregate of which the current subaggregate or contained union is a part.
-<p><!--para 21 -->
+<p><a name="6.7.8p21" href="#6.7.8p21"><small>21</small></a>
  If there are fewer initializers in a brace-enclosed list than there are elements or members
  of an aggregate, or fewer characters in a string literal used to initialize an array of known
  size than there are elements in the array, the remainder of the aggregate shall be
  initialized implicitly the same as objects that have static storage duration.
-<p><!--para 22 -->
+<p><a name="6.7.8p22" href="#6.7.8p22"><small>22</small></a>
  If an array of unknown size is initialized, its size is determined by the largest indexed
  element with an explicit initializer. At the end of its initializer list, the array no longer
  has incomplete type.
@@ -6927,10 +6927,10 @@ unsigned long long int
  
  
 <!--page 140 -->
-<p><!--para 23 -->
+<p><a name="6.7.8p23" href="#6.7.8p23"><small>23</small></a>
  The order in which any side effects occur among the initialization list expressions is
  unspecified.<sup><a href="#note133"><b>133)</b></a></sup>
-<p><!--para 24 -->
+<p><a name="6.7.8p24" href="#6.7.8p24"><small>24</small></a>
  EXAMPLE 1       Provided that <a href="#7.3">&lt;complex.h&gt;</a> has been #included, the declarations
 <pre>
           int i = <a href="#3.5">3.5</a>;
@@ -6938,7 +6938,7 @@ unsigned long long int
 </pre>
  define and initialize i with the value 3 and c with the value 5.0 + i3.0.
  
-<p><!--para 25 -->
+<p><a name="6.7.8p25" href="#6.7.8p25"><small>25</small></a>
  EXAMPLE 2 The declaration
 <pre>
           int x[] = { 1, 3, 5 };
@@ -6946,7 +6946,7 @@ unsigned long long int
  defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
  and there are three initializers.
  
-<p><!--para 26 -->
+<p><a name="6.7.8p26" href="#6.7.8p26"><small>26</small></a>
  EXAMPLE 3       The declaration
 <pre>
           int y[4][3] =         {
@@ -6967,7 +6967,7 @@ unsigned long long int
  The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
  next three are taken successively for y[1] and y[2].
  
-<p><!--para 27 -->
+<p><a name="6.7.8p27" href="#6.7.8p27"><small>27</small></a>
  EXAMPLE 4       The declaration
 <pre>
           int z[4][3] = {
@@ -6976,7 +6976,7 @@ unsigned long long int
 </pre>
  initializes the first column of z as specified and initializes the rest with zeros.
  
-<p><!--para 28 -->
+<p><a name="6.7.8p28" href="#6.7.8p28"><small>28</small></a>
  EXAMPLE 5       The declaration
 <pre>
           struct { int a[3], b; } w[] = { { 1 }, 2 };
@@ -6988,7 +6988,7 @@ unsigned long long int
  
  
 <!--page 141 -->
-<p><!--para 29 -->
+<p><a name="6.7.8p29" href="#6.7.8p29"><small>29</small></a>
  EXAMPLE 6         The declaration
 <pre>
            short q[4][3][2] = {
@@ -7028,11 +7028,11 @@ unsigned long long int
            };
 </pre>
  in a fully bracketed form.
-<p><!--para 30 -->
+<p><a name="6.7.8p30" href="#6.7.8p30"><small>30</small></a>
  Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
  cause confusion.
  
-<p><!--para 31 -->
+<p><a name="6.7.8p31" href="#6.7.8p31"><small>31</small></a>
  EXAMPLE 7         One form of initialization that completes array types involves typedef names. Given the
  declaration
 <pre>
@@ -7048,7 +7048,7 @@ unsigned long long int
 </pre>
  due to the rules for incomplete types.
 <!--page 142 -->
-<p><!--para 32 -->
+<p><a name="6.7.8p32" href="#6.7.8p32"><small>32</small></a>
  EXAMPLE 8       The declaration
 <pre>
           char s[] = "abc", t[3] = "abc";
@@ -7067,7 +7067,7 @@ unsigned long long int
  with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
  modify the contents of the array, the behavior is undefined.
  
-<p><!--para 33 -->
+<p><a name="6.7.8p33" href="#6.7.8p33"><small>33</small></a>
  EXAMPLE 9       Arrays can be initialized to correspond to the elements of an enumeration by using
  designators:
 <pre>
@@ -7078,13 +7078,13 @@ unsigned long long int
           };
 </pre>
  
-<p><!--para 34 -->
+<p><a name="6.7.8p34" href="#6.7.8p34"><small>34</small></a>
  EXAMPLE 10       Structure members can be initialized to nonzero values without depending on their order:
 <pre>
           div_t answer = { .quot = 2, .rem = -1 };
 </pre>
  
-<p><!--para 35 -->
+<p><a name="6.7.8p35" href="#6.7.8p35"><small>35</small></a>
  EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
  might be misunderstood:
 <pre>
@@ -7092,18 +7092,18 @@ unsigned long long int
                 { [0].a = {1}, [1].a[0] = 2 };
 </pre>
  
-<p><!--para 36 -->
+<p><a name="6.7.8p36" href="#6.7.8p36"><small>36</small></a>
  EXAMPLE 12       Space can be ''allocated'' from both ends of an array by using a single designator:
 <pre>
           int a[MAX] = {
                 1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
           };
 </pre>
-<p><!--para 37 -->
+<p><a name="6.7.8p37" href="#6.7.8p37"><small>37</small></a>
  In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
  than ten, some of the values provided by the first five initializers will be overridden by the second five.
  
-<p><!--para 38 -->
+<p><a name="6.7.8p38" href="#6.7.8p38"><small>38</small></a>
  EXAMPLE 13       Any member of a union can be initialized:
 <pre>
           union { /* ... */ } u = { .any_member = 42 };
@@ -7132,7 +7132,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.8" href="#6.8">6.8 Statements and blocks</a></h3>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.8p1" href="#6.8p1"><small>1</small></a>
 <pre>
           statement:
                  labeled-statement
@@ -7143,17 +7143,17 @@ unsigned long long int
                  jump-statement
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8p2" href="#6.8p2"><small>2</small></a>
  A statement specifies an action to be performed. Except as indicated, statements are
  executed in sequence.
-<p><!--para 3 -->
+<p><a name="6.8p3" href="#6.8p3"><small>3</small></a>
  A block allows a set of declarations and statements to be grouped into one syntactic unit.
  The initializers of objects that have automatic storage duration, and the variable length
  array declarators of ordinary identifiers with block scope, are evaluated and the values are
  stored in the objects (including storing an indeterminate value in objects without an
  initializer) each time the declaration is reached in the order of execution, as if it were a
  statement, and within each declaration in the order that declarators appear.
-<p><!--para 4 -->
+<p><a name="6.8p4" href="#6.8p4"><small>4</small></a>
  A full expression is an expression that is not part of another expression or of a declarator.
  Each of the following is a full expression: an initializer; the expression in an expression
  statement; the controlling expression of a selection statement (if or switch); the
@@ -7166,7 +7166,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.8.1" href="#6.8.1">6.8.1 Labeled statements</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.8.1p1" href="#6.8.1p1"><small>1</small></a>
 <pre>
           labeled-statement:
                  identifier : statement
@@ -7174,14 +7174,14 @@ unsigned long long int
                  default : statement
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.8.1p2" href="#6.8.1p2"><small>2</small></a>
  A case or default label shall appear only in a switch statement. Further
  constraints on such labels are discussed under the switch statement.
 <!--page 144 -->
-<p><!--para 3 -->
+<p><a name="6.8.1p3" href="#6.8.1p3"><small>3</small></a>
  Label names shall be unique within a function.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.8.1p4" href="#6.8.1p4"><small>4</small></a>
  Any statement may be preceded by a prefix that declares an identifier as a label name.
  Labels in themselves do not alter the flow of control, which continues unimpeded across
  them.
@@ -7190,7 +7190,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.8.2" href="#6.8.2">6.8.2 Compound statement</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.8.2p1" href="#6.8.2p1"><small>1</small></a>
 <pre>
           compound-statement:
                 { block-item-list<sub>opt</sub> }
@@ -7202,24 +7202,24 @@ unsigned long long int
                   statement
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.2p2" href="#6.8.2p2"><small>2</small></a>
  A compound statement is a block.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.8.3" href="#6.8.3">6.8.3 Expression and null statements</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.8.3p1" href="#6.8.3p1"><small>1</small></a>
 <pre>
           expression-statement:
                  expression<sub>opt</sub> ;
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.3p2" href="#6.8.3p2"><small>2</small></a>
  The expression in an expression statement is evaluated as a void expression for its side
  effects.<sup><a href="#note134"><b>134)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.8.3p3" href="#6.8.3p3"><small>3</small></a>
  A null statement (consisting of just a semicolon) performs no operations.
-<p><!--para 4 -->
+<p><a name="6.8.3p4" href="#6.8.3p4"><small>4</small></a>
  EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
  discarding of its value may be made explicit by converting the expression to a void expression by means of
  a cast:
@@ -7232,7 +7232,7 @@ unsigned long long int
  
  
 <!--page 145 -->
-<p><!--para 5 -->
+<p><a name="6.8.3p5" href="#6.8.3p5"><small>5</small></a>
  EXAMPLE 2       In the program fragment
 <pre>
           char *s;
@@ -7242,7 +7242,7 @@ unsigned long long int
 </pre>
  a null statement is used to supply an empty loop body to the iteration statement.
  
-<p><!--para 6 -->
+<p><a name="6.8.3p6" href="#6.8.3p6"><small>6</small></a>
  EXAMPLE 3       A null statement may also be used to carry a label just before the closing } of a compound
  statement.
 <pre>
@@ -7268,7 +7268,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.8.4" href="#6.8.4">6.8.4 Selection statements</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.8.4p1" href="#6.8.4p1"><small>1</small></a>
 <pre>
           selection-statement:
                   if ( expression ) statement
@@ -7276,10 +7276,10 @@ unsigned long long int
                   switch ( expression ) statement
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.4p2" href="#6.8.4p2"><small>2</small></a>
  A selection statement selects among a set of statements depending on the value of a
  controlling expression.
-<p><!--para 3 -->
+<p><a name="6.8.4p3" href="#6.8.4p3"><small>3</small></a>
  A selection statement is a block whose scope is a strict subset of the scope of its
  enclosing block. Each associated substatement is also a block whose scope is a strict
  subset of the scope of the selection statement.
@@ -7287,29 +7287,29 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.4.1" href="#6.8.4.1">6.8.4.1 The if statement</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.8.4.1p1" href="#6.8.4.1p1"><small>1</small></a>
  The controlling expression of an if statement shall have scalar type.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.4.1p2" href="#6.8.4.1p2"><small>2</small></a>
  In both forms, the first substatement is executed if the expression compares unequal to 0.
  In the else form, the second substatement is executed if the expression compares equal
 <!--page 146 -->
  to 0. If the first substatement is reached via a label, the second substatement is not
  executed.
-<p><!--para 3 -->
+<p><a name="6.8.4.1p3" href="#6.8.4.1p3"><small>3</small></a>
  An else is associated with the lexically nearest preceding if that is allowed by the
  syntax.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.4.2" href="#6.8.4.2">6.8.4.2 The switch statement</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.8.4.2p1" href="#6.8.4.2p1"><small>1</small></a>
  The controlling expression of a switch statement shall have integer type.
-<p><!--para 2 -->
+<p><a name="6.8.4.2p2" href="#6.8.4.2p2"><small>2</small></a>
  If a switch statement has an associated case or default label within the scope of an
  identifier with a variably modified type, the entire switch statement shall be within the
  scope of that identifier.<sup><a href="#note135"><b>135)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.8.4.2p3" href="#6.8.4.2p3"><small>3</small></a>
  The expression of each case label shall be an integer constant expression and no two of
  the case constant expressions in the same switch statement shall have the same value
  after conversion. There may be at most one default label in a switch statement.
@@ -7317,12 +7317,12 @@ unsigned long long int
  expressions with values that duplicate case constant expressions in the enclosing
  switch statement.)
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.8.4.2p4" href="#6.8.4.2p4"><small>4</small></a>
  A switch statement causes control to jump to, into, or past the statement that is the
  switch body, depending on the value of a controlling expression, and on the presence of a
  default label and the values of any case labels on or in the switch body. A case or
  default label is accessible only within the closest enclosing switch statement.
-<p><!--para 5 -->
+<p><a name="6.8.4.2p5" href="#6.8.4.2p5"><small>5</small></a>
  The integer promotions are performed on the controlling expression. The constant
  expression in each case label is converted to the promoted type of the controlling
  expression. If a converted value matches that of the promoted controlling expression,
@@ -7331,7 +7331,7 @@ unsigned long long int
  expression matches and there is no default label, no part of the switch body is
  executed.
 <p><b>Implementation limits</b>
-<p><!--para 6 -->
+<p><a name="6.8.4.2p6" href="#6.8.4.2p6"><small>6</small></a>
  As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
  switch statement.
  
@@ -7339,7 +7339,7 @@ unsigned long long int
  
  
 <!--page 147 -->
-<p><!--para 7 -->
+<p><a name="6.8.4.2p7" href="#6.8.4.2p7"><small>7</small></a>
  EXAMPLE        In the artificial program fragment
 <pre>
           switch (expr)
@@ -7366,7 +7366,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.8.5" href="#6.8.5">6.8.5 Iteration statements</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.8.5p1" href="#6.8.5p1"><small>1</small></a>
 <pre>
           iteration-statement:
                   while ( expression ) statement
@@ -7375,17 +7375,17 @@ unsigned long long int
                   for ( declaration expression<sub>opt</sub> ; expression<sub>opt</sub> ) statement
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.8.5p2" href="#6.8.5p2"><small>2</small></a>
  The controlling expression of an iteration statement shall have scalar type.
-<p><!--para 3 -->
+<p><a name="6.8.5p3" href="#6.8.5p3"><small>3</small></a>
  The declaration part of a for statement shall only declare identifiers for objects having
  storage class auto or register.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.8.5p4" href="#6.8.5p4"><small>4</small></a>
  An iteration statement causes a statement called the loop body to be executed repeatedly
  until the controlling expression compares equal to 0. The repetition occurs regardless of
  whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note136"><b>136)</b></a></sup>
-<p><!--para 5 -->
+<p><a name="6.8.5p5" href="#6.8.5p5"><small>5</small></a>
  An iteration statement is a block whose scope is a strict subset of the scope of its
  enclosing block. The loop body is also a block whose scope is a strict subset of the scope
  of the iteration statement.
@@ -7402,19 +7402,19 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.5.1" href="#6.8.5.1">6.8.5.1 The while statement</a></h5>
-<p><!--para 1 -->
+<p><a name="6.8.5.1p1" href="#6.8.5.1p1"><small>1</small></a>
  The evaluation of the controlling expression takes place before each execution of the loop
  body.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.5.2" href="#6.8.5.2">6.8.5.2 The do statement</a></h5>
-<p><!--para 1 -->
+<p><a name="6.8.5.2p1" href="#6.8.5.2p1"><small>1</small></a>
  The evaluation of the controlling expression takes place after each execution of the loop
  body.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.5.3" href="#6.8.5.3">6.8.5.3 The for statement</a></h5>
-<p><!--para 1 -->
+<p><a name="6.8.5.3p1" href="#6.8.5.3p1"><small>1</small></a>
  The statement
 <pre>
           for ( clause-1 ; expression-2 ; expression-3 ) statement
@@ -7426,7 +7426,7 @@ unsigned long long int
  the entire loop, including the other two expressions; it is reached in the order of execution
  before the first evaluation of the controlling expression. If clause-1 is an expression, it is
  evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note137"><b>137)</b></a></sup>
-<p><!--para 2 -->
+<p><a name="6.8.5.3p2" href="#6.8.5.3p2"><small>2</small></a>
  Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a
  nonzero constant.
 
@@ -7440,7 +7440,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.8.6" href="#6.8.6">6.8.6 Jump statements</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.8.6p1" href="#6.8.6p1"><small>1</small></a>
 <pre>
           jump-statement:
                  goto identifier ;
@@ -7449,7 +7449,7 @@ unsigned long long int
                  return expression<sub>opt</sub> ;
 </pre>
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.6p2" href="#6.8.6p2"><small>2</small></a>
  A jump statement causes an unconditional jump to another place.
  
  
@@ -7460,15 +7460,15 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.6.1" href="#6.8.6.1">6.8.6.1 The goto statement</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.8.6.1p1" href="#6.8.6.1p1"><small>1</small></a>
  The identifier in a goto statement shall name a label located somewhere in the enclosing
  function. A goto statement shall not jump from outside the scope of an identifier having
  a variably modified type to inside the scope of that identifier.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.6.1p2" href="#6.8.6.1p2"><small>2</small></a>
  A goto statement causes an unconditional jump to the statement prefixed by the named
  label in the enclosing function.
-<p><!--para 3 -->
+<p><a name="6.8.6.1p3" href="#6.8.6.1p3"><small>3</small></a>
  EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
  following outline presents one possible approach to a problem based on these three assumptions:
 <ol>
@@ -7496,7 +7496,7 @@ unsigned long long int
 </pre>
 <!--page 150 -->
 </ol>
-<p><!--para 4 -->
+<p><a name="6.8.6.1p4" href="#6.8.6.1p4"><small>4</small></a>
  EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
  modified types. A jump within the scope, however, is permitted.
 <pre>
@@ -7518,10 +7518,10 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.6.2" href="#6.8.6.2">6.8.6.2 The continue statement</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.8.6.2p1" href="#6.8.6.2p1"><small>1</small></a>
  A continue statement shall appear only in or as a loop body.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.6.2p2" href="#6.8.6.2p2"><small>2</small></a>
  A continue statement causes a jump to the loop-continuation portion of the smallest
  enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
  of the statements
@@ -7543,10 +7543,10 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.6.3" href="#6.8.6.3">6.8.6.3 The break statement</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.8.6.3p1" href="#6.8.6.3p1"><small>1</small></a>
  A break statement shall appear only in or as a switch body or loop body.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.6.3p2" href="#6.8.6.3p2"><small>2</small></a>
  A break statement terminates execution of the smallest enclosing switch or iteration
  statement.
  
@@ -7557,20 +7557,20 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.8.6.4" href="#6.8.6.4">6.8.6.4 The return statement</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.8.6.4p1" href="#6.8.6.4p1"><small>1</small></a>
  A return statement with an expression shall not appear in a function whose return type
  is void. A return statement without an expression shall only appear in a function
  whose return type is void.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.8.6.4p2" href="#6.8.6.4p2"><small>2</small></a>
  A return statement terminates execution of the current function and returns control to
  its caller. A function may have any number of return statements.
-<p><!--para 3 -->
+<p><a name="6.8.6.4p3" href="#6.8.6.4p3"><small>3</small></a>
  If a return statement with an expression is executed, the value of the expression is
  returned to the caller as the value of the function call expression. If the expression has a
  type different from the return type of the function in which it appears, the value is
  converted as if by assignment to an object having the return type of the function.<sup><a href="#note139"><b>139)</b></a></sup>
-<p><!--para 4 -->
+<p><a name="6.8.6.4p4" href="#6.8.6.4p4"><small>4</small></a>
  EXAMPLE       In:
 <pre>
          struct s { double i; } f(void);
@@ -7609,7 +7609,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.9" href="#6.9">6.9 External definitions</a></h3>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.9p1" href="#6.9p1"><small>1</small></a>
 <pre>
           translation-unit:
                   external-declaration
@@ -7619,23 +7619,23 @@ unsigned long long int
                  declaration
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.9p2" href="#6.9p2"><small>2</small></a>
  The storage-class specifiers auto and register shall not appear in the declaration
  specifiers in an external declaration.
-<p><!--para 3 -->
+<p><a name="6.9p3" href="#6.9p3"><small>3</small></a>
  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.
 <p><b>Semantics</b>
-<p><!--para 4 -->
+<p><a name="6.9p4" href="#6.9p4"><small>4</small></a>
  As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
  which consists of a sequence of external declarations. These are described as ''external''
  because they appear outside any function (and hence have file scope). As discussed in
  <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
  by the identifier is a definition.
-<p><!--para 5 -->
+<p><a name="6.9p5" href="#6.9p5"><small>5</small></a>
  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
@@ -7656,7 +7656,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.9.1" href="#6.9.1">6.9.1 Function definitions</a></h4>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.9.1p1" href="#6.9.1p1"><small>1</small></a>
 <pre>
           function-definition:
                  declaration-specifiers declarator declaration-list<sub>opt</sub> compound-statement
@@ -7665,20 +7665,20 @@ unsigned long long int
                  declaration-list declaration
 </pre>
 <p><b>Constraints</b>
-<p><!--para 2 -->
+<p><a name="6.9.1p2" href="#6.9.1p2"><small>2</small></a>
  The identifier declared in a function definition (which is the name of the function) shall
  have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note141"><b>141)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.9.1p3" href="#6.9.1p3"><small>3</small></a>
  The return type of a function shall be void or an object type other than array type.
-<p><!--para 4 -->
+<p><a name="6.9.1p4" href="#6.9.1p4"><small>4</small></a>
  The storage-class specifier, if any, in the declaration specifiers shall be either extern or
  static.
-<p><!--para 5 -->
+<p><a name="6.9.1p5" href="#6.9.1p5"><small>5</small></a>
  If the declarator includes a parameter type list, the declaration of each parameter shall
  include an identifier, except for the special case of a parameter list consisting of a single
  parameter of type void, in which case there shall not be an identifier. No declaration list
  shall follow.
-<p><!--para 6 -->
+<p><a name="6.9.1p6" href="#6.9.1p6"><small>6</small></a>
  If the declarator includes an identifier list, each declaration in the declaration list shall
  have at least one declarator, those declarators shall declare only identifiers from the
  identifier list, and every identifier in the identifier list shall be declared. An identifier
@@ -7691,7 +7691,7 @@ unsigned long long int
  
 <!--page 154 -->
 <p><b>Semantics</b>
-<p><!--para 7 -->
+<p><a name="6.9.1p7" href="#6.9.1p7"><small>7</small></a>
  The declarator in a function definition specifies the name of the function being defined
  and the identifiers of its parameters. If the declarator includes a parameter type list, the
  list also specifies the types of all the parameters; such a declarator also serves as a
@@ -7699,26 +7699,26 @@ unsigned long long int
  declarator includes an identifier list,<sup><a href="#note142"><b>142)</b></a></sup> the types of the parameters shall be declared in a
  following declaration list. In either case, the type of each parameter is adjusted as
  described in <a href="#6.7.5.3">6.7.5.3</a> for a parameter type list; the resulting type shall be an object type.
-<p><!--para 8 -->
+<p><a name="6.9.1p8" href="#6.9.1p8"><small>8</small></a>
  If a function that accepts a variable number of arguments is defined without a parameter
  type list that ends with the ellipsis notation, the behavior is undefined.
-<p><!--para 9 -->
+<p><a name="6.9.1p9" href="#6.9.1p9"><small>9</small></a>
  Each parameter has automatic storage duration. Its identifier is an lvalue, which is in
  effect declared at the head of the compound statement that constitutes the function body
  (and therefore cannot be redeclared in the function body except in an enclosed block).
  The layout of the storage for parameters is unspecified.
-<p><!--para 10 -->
+<p><a name="6.9.1p10" href="#6.9.1p10"><small>10</small></a>
  On entry to the function, the size expressions of each variably modified parameter are
  evaluated and the value of each argument expression is converted to the type of the
  corresponding parameter as if by assignment. (Array expressions and function
  designators as arguments were converted to pointers before the call.)
-<p><!--para 11 -->
+<p><a name="6.9.1p11" href="#6.9.1p11"><small>11</small></a>
  After all parameters have been assigned, the compound statement that constitutes the
  body of the function definition is executed.
-<p><!--para 12 -->
+<p><a name="6.9.1p12" href="#6.9.1p12"><small>12</small></a>
  If the } that terminates a function is reached, and the value of the function call is used by
  the caller, the behavior is undefined.
-<p><!--para 13 -->
+<p><a name="6.9.1p13" href="#6.9.1p13"><small>13</small></a>
  EXAMPLE 1       In the following:
 <pre>
           extern int max(int a, int b)
@@ -7749,7 +7749,7 @@ unsigned long long int
  that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
  to the function, whereas the second form does not.
  
-<p><!--para 14 -->
+<p><a name="6.9.1p14" href="#6.9.1p14"><small>14</small></a>
  EXAMPLE 2           To pass one function to another, one might say
 <pre>
                       int f(void);
@@ -7797,10 +7797,10 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.9.2" href="#6.9.2">6.9.2 External object definitions</a></h4>
 <p><b>Semantics</b>
-<p><!--para 1 -->
+<p><a name="6.9.2p1" href="#6.9.2p1"><small>1</small></a>
  If the declaration of an identifier for an object has file scope and an initializer, the
  declaration is an external definition for the identifier.
-<p><!--para 2 -->
+<p><a name="6.9.2p2" href="#6.9.2p2"><small>2</small></a>
  A declaration of an identifier for an object that has file scope without an initializer, and
  without a storage-class specifier or with the storage-class specifier static, constitutes a
  tentative definition. If a translation unit contains one or more tentative definitions for an
@@ -7808,11 +7808,11 @@ unsigned long long int
  the behavior is exactly as if the translation unit contains a file scope declaration of that
  identifier, with the composite type as of the end of the translation unit, with an initializer
  equal to 0.
-<p><!--para 3 -->
+<p><a name="6.9.2p3" href="#6.9.2p3"><small>3</small></a>
  If the declaration of an identifier for an object is a tentative definition and has internal
  linkage, the declared type shall not be an incomplete type.
 <!--page 156 -->
-<p><!--para 4 -->
+<p><a name="6.9.2p4" href="#6.9.2p4"><small>4</small></a>
  EXAMPLE 1
 <pre>
           int i1 = 1;                    // definition, external linkage
@@ -7832,7 +7832,7 @@ unsigned long long int
           extern    int   i5;            // refers to previous, whose linkage is internal
 </pre>
  
-<p><!--para 5 -->
+<p><a name="6.9.2p5" href="#6.9.2p5"><small>5</small></a>
  EXAMPLE 2       If at the end of the translation unit containing
 <pre>
           int i[];
@@ -7844,7 +7844,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="6.10" href="#6.10">6.10 Preprocessing directives</a></h3>
 <p><b>Syntax</b>
-<p><!--para 1 -->
+<p><a name="6.10p1" href="#6.10p1"><small>1</small></a>
 <!--page 158 -->
 <pre>
           preprocessing-file:
@@ -7900,7 +7900,7 @@ unsigned long long int
                  the new-line character
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="6.10p2" href="#6.10p2"><small>2</small></a>
  A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
  following constraints: The first token in the sequence is a # preprocessing token that (at
  the start of translation phase 4) is either the first character in the source file (optionally
@@ -7911,29 +7911,29 @@ unsigned long long int
  
 <!--page 159 -->
  invocation of a function-like macro.
-<p><!--para 3 -->
+<p><a name="6.10p3" href="#6.10p3"><small>3</small></a>
  A text line shall not begin with a # preprocessing token. A non-directive shall not begin
  with any of the directive names appearing in the syntax.
-<p><!--para 4 -->
+<p><a name="6.10p4" href="#6.10p4"><small>4</small></a>
  When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
  sequence of preprocessing tokens to occur between the directive name and the following
  new-line character.
 <p><b>Constraints</b>
-<p><!--para 5 -->
+<p><a name="6.10p5" href="#6.10p5"><small>5</small></a>
  The only white-space characters that shall appear between preprocessing tokens within a
  preprocessing directive (from just after the introducing # preprocessing token through
  just before the terminating new-line character) are space and horizontal-tab (including
  spaces that have replaced comments or possibly other white-space characters in
  translation phase 3).
 <p><b>Semantics</b>
-<p><!--para 6 -->
+<p><a name="6.10p6" href="#6.10p6"><small>6</small></a>
  The implementation can process and skip sections of source files conditionally, include
  other source files, and replace macros. These capabilities are called preprocessing,
  because conceptually they occur before translation of the resulting translation unit.
-<p><!--para 7 -->
+<p><a name="6.10p7" href="#6.10p7"><small>7</small></a>
  The preprocessing tokens within a preprocessing directive are not subject to macro
  expansion unless otherwise stated.
-<p><!--para 8 -->
+<p><a name="6.10p8" href="#6.10p8"><small>8</small></a>
  EXAMPLE        In:
 <pre>
           #define EMPTY
@@ -7953,7 +7953,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.1" href="#6.10.1">6.10.1 Conditional inclusion</a></h4>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.10.1p1" href="#6.10.1p1"><small>1</small></a>
  The expression that controls conditional inclusion shall be an integer constant expression
  except that: it shall not contain a cast; identifiers (including those lexically identical to
  keywords) are interpreted as described below;<sup><a href="#note144"><b>144)</b></a></sup> and it may contain unary operator
@@ -7973,19 +7973,19 @@ unsigned long long int
  which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
  predefined or if it has been the subject of a #define preprocessing directive without an
  intervening #undef directive with the same subject identifier), 0 if it is not.
-<p><!--para 2 -->
+<p><a name="6.10.1p2" href="#6.10.1p2"><small>2</small></a>
  Each preprocessing token that remains (in the list of preprocessing tokens that will
  become the controlling expression) after all macro replacements have occurred shall be in
  the lexical form of a token (<a href="#6.4">6.4</a>).
 <p><b>Semantics</b>
-<p><!--para 3 -->
+<p><a name="6.10.1p3" href="#6.10.1p3"><small>3</small></a>
  Preprocessing directives of the forms
 <pre>
       # if   constant-expression new-line group<sub>opt</sub>
       # elif constant-expression new-line group<sub>opt</sub>
 </pre>
  check whether the controlling constant expression evaluates to nonzero.
-<p><!--para 4 -->
+<p><a name="6.10.1p4" href="#6.10.1p4"><small>4</small></a>
  Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
  the controlling constant expression are replaced (except for those macro names modified
  by the defined unary operator), just as in normal text. If the token defined is
@@ -8004,7 +8004,7 @@ unsigned long long int
  the value obtained when an identical character constant occurs in an expression (other
  than within a #if or #elif directive) is implementation-defined.<sup><a href="#note146"><b>146)</b></a></sup> Also, whether a
  single-character character constant may have a negative value is implementation-defined.
-<p><!--para 5 -->
+<p><a name="6.10.1p5" href="#6.10.1p5"><small>5</small></a>
  Preprocessing directives of the forms
  
  
@@ -8017,7 +8017,7 @@ unsigned long long int
  check whether the identifier is or is not currently defined as a macro name. Their
  conditions are equivalent to #if defined identifier and #if !defined identifier
  respectively.
-<p><!--para 6 -->
+<p><a name="6.10.1p6" href="#6.10.1p6"><small>6</small></a>
  Each directive's condition is checked in order. If it evaluates to false (zero), the group
  that it controls is skipped: directives are processed only through the name that determines
  the directive in order to keep track of the level of nested conditionals; the rest of the
@@ -8053,11 +8053,11 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.2" href="#6.10.2">6.10.2 Source file inclusion</a></h4>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.10.2p1" href="#6.10.2p1"><small>1</small></a>
  A #include directive shall identify a header or source file that can be processed by the
  implementation.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.10.2p2" href="#6.10.2p2"><small>2</small></a>
  A preprocessing directive of the form
 <pre>
     # include &lt;h-char-sequence&gt; new-line
@@ -8066,7 +8066,7 @@ unsigned long long int
  the specified sequence between the &lt; and &gt; delimiters, and causes the replacement of that
  directive by the entire contents of the header. How the places are specified or the header
  identified is implementation-defined.
-<p><!--para 3 -->
+<p><a name="6.10.2p3" href="#6.10.2p3"><small>3</small></a>
  A preprocessing directive of the form
  
  
@@ -8084,7 +8084,7 @@ unsigned long long int
 </pre>
  with the identical contained sequence (including &gt; characters, if any) from the original
  directive.
-<p><!--para 4 -->
+<p><a name="6.10.2p4" href="#6.10.2p4"><small>4</small></a>
  A preprocessing directive of the form
 <pre>
     # include pp-tokens new-line
@@ -8096,24 +8096,24 @@ unsigned long long int
  the two previous forms.<sup><a href="#note148"><b>148)</b></a></sup> The method by which a sequence of preprocessing tokens
  between a &lt; and a &gt; preprocessing token pair or a pair of " characters is combined into a
  single header name preprocessing token is implementation-defined.
-<p><!--para 5 -->
+<p><a name="6.10.2p5" href="#6.10.2p5"><small>5</small></a>
  The implementation shall provide unique mappings for sequences consisting of one or
  more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
  first character shall not be a digit. The implementation may ignore distinctions of
  alphabetical case and restrict the mapping to eight significant characters before the
  period.
-<p><!--para 6 -->
+<p><a name="6.10.2p6" href="#6.10.2p6"><small>6</small></a>
  A #include preprocessing directive may appear in a source file that has been read
  because of a #include directive in another file, up to an implementation-defined
  nesting limit (see <a href="#5.2.4.1">5.2.4.1</a>).
-<p><!--para 7 -->
+<p><a name="6.10.2p7" href="#6.10.2p7"><small>7</small></a>
  EXAMPLE 1       The most common uses of #include preprocessing directives are as in the following:
 <pre>
           #include <a href="#7.19">&lt;stdio.h&gt;</a>
           #include "myprog.h"
 </pre>
  
-<p><!--para 8 -->
+<p><a name="6.10.2p8" href="#6.10.2p8"><small>8</small></a>
  EXAMPLE 2       This illustrates macro-replaced #include directives:
  
  
@@ -8141,11 +8141,11 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.3" href="#6.10.3">6.10.3 Macro replacement</a></h4>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.10.3p1" href="#6.10.3p1"><small>1</small></a>
  Two replacement lists are identical if and only if the preprocessing tokens in both have
  the same number, ordering, spelling, and white-space separation, where all white-space
  separations are considered identical.
-<p><!--para 2 -->
+<p><a name="6.10.3p2" href="#6.10.3p2"><small>2</small></a>
  An identifier currently defined as an object-like macro shall not be redefined by another
  #define preprocessing directive unless the second definition is an object-like macro
  definition and the two replacement lists are identical. Likewise, an identifier currently
@@ -8153,33 +8153,33 @@ unsigned long long int
  preprocessing directive unless the second definition is a function-like macro definition
  that has the same number and spelling of parameters, and the two replacement lists are
  identical.
-<p><!--para 3 -->
+<p><a name="6.10.3p3" href="#6.10.3p3"><small>3</small></a>
  There shall be white-space between the identifier and the replacement list in the definition
  of an object-like macro.
-<p><!--para 4 -->
+<p><a name="6.10.3p4" href="#6.10.3p4"><small>4</small></a>
  If the identifier-list in the macro definition does not end with an ellipsis, the number of
  arguments (including those arguments consisting of no preprocessing tokens) in an
  invocation of a function-like macro shall equal the number of parameters in the macro
  definition. Otherwise, there shall be more arguments in the invocation than there are
  parameters in the macro definition (excluding the ...). There shall exist a )
  preprocessing token that terminates the invocation.
-<p><!--para 5 -->
+<p><a name="6.10.3p5" href="#6.10.3p5"><small>5</small></a>
  The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
  macro that uses the ellipsis notation in the parameters.
-<p><!--para 6 -->
+<p><a name="6.10.3p6" href="#6.10.3p6"><small>6</small></a>
  A parameter identifier in a function-like macro shall be uniquely declared within its
  scope.
 <p><b>Semantics</b>
-<p><!--para 7 -->
+<p><a name="6.10.3p7" href="#6.10.3p7"><small>7</small></a>
  The identifier immediately following the define is called the macro name. There is one
  name space for macro names. Any white-space characters preceding or following the
  replacement list of preprocessing tokens are not considered part of the replacement list
  for either form of macro.
 <!--page 164 -->
-<p><!--para 8 -->
+<p><a name="6.10.3p8" href="#6.10.3p8"><small>8</small></a>
  If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
  a preprocessing directive could begin, the identifier is not subject to macro replacement.
-<p><!--para 9 -->
+<p><a name="6.10.3p9" href="#6.10.3p9"><small>9</small></a>
  A preprocessing directive of the form
 <pre>
     # define identifier replacement-list new-line
@@ -8188,7 +8188,7 @@ unsigned long long int
  to be replaced by the replacement list of preprocessing tokens that constitute the
  remainder of the directive. The replacement list is then rescanned for more macro names
  as specified below.
-<p><!--para 10 -->
+<p><a name="6.10.3p10" href="#6.10.3p10"><small>10</small></a>
  A preprocessing directive of the form
 <pre>
     # define identifier lparen identifier-list<sub>opt</sub> ) replacement-list new-line
@@ -8206,14 +8206,14 @@ unsigned long long int
  left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
  tokens making up an invocation of a function-like macro, new-line is considered a normal
  white-space character.
-<p><!--para 11 -->
+<p><a name="6.10.3p11" href="#6.10.3p11"><small>11</small></a>
  The sequence of preprocessing tokens bounded by the outside-most matching parentheses
  forms the list of arguments for the function-like macro. The individual arguments within
  the list are separated by comma preprocessing tokens, but comma preprocessing tokens
  between matching inner parentheses do not separate arguments. If there are sequences of
  preprocessing tokens within the list of arguments that would otherwise act as
  preprocessing directives,<sup><a href="#note150"><b>150)</b></a></sup> the behavior is undefined.
-<p><!--para 12 -->
+<p><a name="6.10.3p12" href="#6.10.3p12"><small>12</small></a>
  If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
  including any separating comma preprocessing tokens, are merged to form a single item:
  the variable arguments. The number of arguments so combined is such that, following
@@ -8233,7 +8233,7 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.10.3.1" href="#6.10.3.1">6.10.3.1 Argument substitution</a></h5>
-<p><!--para 1 -->
+<p><a name="6.10.3.1p1" href="#6.10.3.1p1"><small>1</small></a>
  After the arguments for the invocation of a function-like macro have been identified,
  argument substitution takes place. A parameter in the replacement list, unless preceded
  by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
@@ -8241,7 +8241,7 @@ unsigned long long int
  expanded. Before being substituted, each argument's preprocessing tokens are
  completely macro replaced as if they formed the rest of the preprocessing file; no other
  preprocessing tokens are available.
-<p><!--para 2 -->
+<p><a name="6.10.3.1p2" href="#6.10.3.1p2"><small>2</small></a>
  An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
  were a parameter, and the variable arguments shall form the preprocessing tokens used to
  replace it.
@@ -8249,11 +8249,11 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.10.3.2" href="#6.10.3.2">6.10.3.2 The # operator</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.10.3.2p1" href="#6.10.3.2p1"><small>1</small></a>
  Each # preprocessing token in the replacement list for a function-like macro shall be
  followed by a parameter as the next preprocessing token in the replacement list.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.10.3.2p2" href="#6.10.3.2p2"><small>2</small></a>
  If, in the replacement list, a parameter is immediately preceded by a # preprocessing
  token, both are replaced by a single character string literal preprocessing token that
  contains the spelling of the preprocessing token sequence for the corresponding
@@ -8274,17 +8274,17 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.10.3.3" href="#6.10.3.3">6.10.3.3 The ## operator</a></h5>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.10.3.3p1" href="#6.10.3.3p1"><small>1</small></a>
  A ## preprocessing token shall not occur at the beginning or at the end of a replacement
  list for either form of macro definition.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.10.3.3p2" href="#6.10.3.3p2"><small>2</small></a>
  If, in the replacement list of a function-like macro, a parameter is immediately preceded
  or followed by a ## preprocessing token, the parameter is replaced by the corresponding
  argument's preprocessing token sequence; however, if an argument consists of no
  preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
  instead.<sup><a href="#note151"><b>151)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="6.10.3.3p3" href="#6.10.3.3p3"><small>3</small></a>
  For both object-like and function-like macro invocations, before the replacement list is
  reexamined for more macro names to replace, each instance of a ## preprocessing token
  in the replacement list (not from an argument) is deleted and the preceding preprocessing
@@ -8295,7 +8295,7 @@ unsigned long long int
  If the result is not a valid preprocessing token, the behavior is undefined. The resulting
  token is available for further macro replacement. The order of evaluation of ## operators
  is unspecified.
-<p><!--para 4 -->
+<p><a name="6.10.3.3p4" href="#6.10.3.3p4"><small>4</small></a>
  EXAMPLE       In the following fragment:
 <pre>
          #define     hash_hash # ## #
@@ -8326,44 +8326,44 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.10.3.4" href="#6.10.3.4">6.10.3.4 Rescanning and further replacement</a></h5>
-<p><!--para 1 -->
+<p><a name="6.10.3.4p1" href="#6.10.3.4p1"><small>1</small></a>
  After all parameters in the replacement list have been substituted and # and ##
  processing has taken place, all placemarker preprocessing tokens are removed. Then, the
  resulting preprocessing token sequence is rescanned, along with all subsequent
  preprocessing tokens of the source file, for more macro names to replace.
-<p><!--para 2 -->
+<p><a name="6.10.3.4p2" href="#6.10.3.4p2"><small>2</small></a>
  If the name of the macro being replaced is found during this scan of the replacement list
  (not including the rest of the source file's preprocessing tokens), it is not replaced.
  Furthermore, if any nested replacements encounter the name of the macro being replaced,
  it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
  available for further replacement even if they are later (re)examined in contexts in which
  that macro name preprocessing token would otherwise have been replaced.
-<p><!--para 3 -->
+<p><a name="6.10.3.4p3" href="#6.10.3.4p3"><small>3</small></a>
  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.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="6.10.3.5" href="#6.10.3.5">6.10.3.5 Scope of macro definitions</a></h5>
-<p><!--para 1 -->
+<p><a name="6.10.3.5p1" href="#6.10.3.5p1"><small>1</small></a>
  A macro definition lasts (independent of block structure) until a corresponding #undef
  directive is encountered or (if none is encountered) until the end of the preprocessing
  translation unit. Macro definitions have no significance after translation phase 4.
-<p><!--para 2 -->
+<p><a name="6.10.3.5p2" href="#6.10.3.5p2"><small>2</small></a>
  A preprocessing directive of the form
 <pre>
     # undef identifier new-line
 </pre>
  causes the specified identifier no longer to be defined as a macro name. It is ignored if
  the specified identifier is not currently defined as a macro name.
-<p><!--para 3 -->
+<p><a name="6.10.3.5p3" href="#6.10.3.5p3"><small>3</small></a>
  EXAMPLE 1      The simplest use of this facility is to define a ''manifest constant'', as in
 <pre>
          #define TABSIZE 100
          int table[TABSIZE];
 </pre>
  
-<p><!--para 4 -->
+<p><a name="6.10.3.5p4" href="#6.10.3.5p4"><small>4</small></a>
  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
@@ -8374,7 +8374,7 @@ unsigned long long int
 </pre>
  The parentheses ensure that the arguments and the resulting expression are bound properly.
 <!--page 168 -->
-<p><!--para 5 -->
+<p><a name="6.10.3.5p5" href="#6.10.3.5p5"><small>5</small></a>
  EXAMPLE 3     To illustrate the rules for redefinition and reexamination, the sequence
 <pre>
           #define   x         3
@@ -8405,7 +8405,7 @@ unsigned long long int
           char c[2][6] = { "hello", "" };
 </pre>
  
-<p><!--para 6 -->
+<p><a name="6.10.3.5p6" href="#6.10.3.5p6"><small>6</small></a>
  EXAMPLE 4     To illustrate the rules for creating character string literals and concatenating tokens, the
  sequence
 <pre>
@@ -8448,7 +8448,7 @@ unsigned long long int
 </pre>
  Space around the # and ## tokens in the macro definition is optional.
  
-<p><!--para 7 -->
+<p><a name="6.10.3.5p7" href="#6.10.3.5p7"><small>7</small></a>
  EXAMPLE 5        To illustrate the rules for placemarker preprocessing tokens, the sequence
 <pre>
           #define t(x,y,z) x ## y ## z
@@ -8461,7 +8461,7 @@ unsigned long long int
                       10, 11, 12, };
 </pre>
  
-<p><!--para 8 -->
+<p><a name="6.10.3.5p8" href="#6.10.3.5p8"><small>8</small></a>
  EXAMPLE 6        To demonstrate the redefinition rules, the following sequence is valid.
 <pre>
           #define      OBJ_LIKE      (1-1)
@@ -8479,7 +8479,7 @@ unsigned long long int
           #define      FUNC_LIKE(b) ( b ) // different parameter spelling
 </pre>
  
-<p><!--para 9 -->
+<p><a name="6.10.3.5p9" href="#6.10.3.5p9"><small>9</small></a>
  EXAMPLE 7        Finally, to show the variable argument list macro facilities:
 <!--page 170 -->
 <pre>
@@ -8505,14 +8505,14 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.4" href="#6.10.4">6.10.4 Line control</a></h4>
 <p><b>Constraints</b>
-<p><!--para 1 -->
+<p><a name="6.10.4p1" href="#6.10.4p1"><small>1</small></a>
  The string literal of a #line directive, if present, shall be a character string literal.
 <p><b>Semantics</b>
-<p><!--para 2 -->
+<p><a name="6.10.4p2" href="#6.10.4p2"><small>2</small></a>
  The line number of the current source line is one greater than the number of new-line
  characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
  file to the current token.
-<p><!--para 3 -->
+<p><a name="6.10.4p3" href="#6.10.4p3"><small>3</small></a>
  A preprocessing directive of the form
 <pre>
     # line digit-sequence new-line
@@ -8521,14 +8521,14 @@ unsigned long long int
  with a source line that has a line number as specified by the digit sequence (interpreted as
  a decimal integer). The digit sequence shall not specify zero, nor a number greater than
  2147483647.
-<p><!--para 4 -->
+<p><a name="6.10.4p4" href="#6.10.4p4"><small>4</small></a>
  A preprocessing directive of the form
 <pre>
     # line digit-sequence "s-char-sequence<sub>opt</sub>" new-line
 </pre>
  sets the presumed line number similarly and changes the presumed name of the source
  file to be the contents of the character string literal.
-<p><!--para 5 -->
+<p><a name="6.10.4p5" href="#6.10.4p5"><small>5</small></a>
  A preprocessing directive of the form
 <pre>
     # line pp-tokens new-line
@@ -8543,7 +8543,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.5" href="#6.10.5">6.10.5 Error directive</a></h4>
 <p><b>Semantics</b>
-<p><!--para 1 -->
+<p><a name="6.10.5p1" href="#6.10.5p1"><small>1</small></a>
  A preprocessing directive of the form
 <pre>
     # error pp-tokens<sub>opt</sub> new-line
@@ -8554,7 +8554,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.6" href="#6.10.6">6.10.6 Pragma directive</a></h4>
 <p><b>Semantics</b>
-<p><!--para 1 -->
+<p><a name="6.10.6p1" href="#6.10.6p1"><small>1</small></a>
  A preprocessing directive of the form
 <pre>
     # pragma pp-tokens<sub>opt</sub> new-line
@@ -8564,7 +8564,7 @@ unsigned long long int
  implementation-defined manner. The behavior might cause translation to fail or cause the
  translator or the resulting program to behave in a non-conforming manner. Any such
  pragma that is not recognized by the implementation is ignored.
-<p><!--para 2 -->
+<p><a name="6.10.6p2" href="#6.10.6p2"><small>2</small></a>
  If the preprocessing token STDC does immediately follow pragma in the directive (prior
  to any macro replacement), then no macro replacement is performed on the directive, and
  the directive shall have one of the following forms<sup><a href="#note153"><b>153)</b></a></sup> whose meanings are described
@@ -8597,7 +8597,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.7" href="#6.10.7">6.10.7 Null directive</a></h4>
 <p><b>Semantics</b>
-<p><!--para 1 -->
+<p><a name="6.10.7p1" href="#6.10.7p1"><small>1</small></a>
  A preprocessing directive of the form
 <pre>
     # new-line
@@ -8606,7 +8606,7 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.8" href="#6.10.8">6.10.8 Predefined macro names</a></h4>
-<p><!--para 1 -->
+<p><a name="6.10.8p1" href="#6.10.8p1"><small>1</small></a>
  The following macro names<sup><a href="#note154"><b>154)</b></a></sup> shall be defined by the implementation:
 <dl>
 <dt> __DATE__ <dd>The date of translation of the preprocessing translation unit: a character
@@ -8634,7 +8634,7 @@ unsigned long long int
  
  
 <!--page 173 -->
-<p><!--para 2 -->
+<p><a name="6.10.8p2" href="#6.10.8p2"><small>2</small></a>
  The following macro names are conditionally defined by the implementation:
 <dl>
 <dt> __STDC_IEC_559__ <dd>The integer constant 1, intended to indicate conformance to the
@@ -8650,15 +8650,15 @@ unsigned long long int
            all amendments and technical corrigenda, as of the specified year and
            month.
 </dl>
-<p><!--para 3 -->
+<p><a name="6.10.8p3" href="#6.10.8p3"><small>3</small></a>
  The values of the predefined macros (except for __FILE__ and __LINE__) remain
  constant throughout the translation unit.
-<p><!--para 4 -->
+<p><a name="6.10.8p4" href="#6.10.8p4"><small>4</small></a>
  None of these macro names, nor the identifier defined, shall be the subject of a
  #define or a #undef preprocessing directive. Any other predefined macro names
  shall begin with a leading underscore followed by an uppercase letter or a second
  underscore.
-<p><!--para 5 -->
+<p><a name="6.10.8p5" href="#6.10.8p5"><small>5</small></a>
  The implementation shall not predefine the macro __cplusplus, nor shall it define it
  in any standard header.
 <p><b> Forward references</b>: the asctime function (<a href="#7.23.3.1">7.23.3.1</a>), standard headers (<a href="#7.1.2">7.1.2</a>).
@@ -8676,7 +8676,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.10.9" href="#6.10.9">6.10.9 Pragma operator</a></h4>
 <p><b>Semantics</b>
-<p><!--para 1 -->
+<p><a name="6.10.9p1" href="#6.10.9p1"><small>1</small></a>
  A unary operator expression of the form:
 <pre>
     _Pragma ( string-literal )
@@ -8688,7 +8688,7 @@ unsigned long long int
  preprocessing tokens that are executed as if they were the pp-tokens in a pragma
  directive. The original four preprocessing tokens in the unary operator expression are
  removed.
-<p><!--para 2 -->
+<p><a name="6.10.9p2" href="#6.10.9p2"><small>2</small></a>
  EXAMPLE       A directive of the form:
 <pre>
           #pragma listing on "..\listing.dir"
@@ -8712,55 +8712,55 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.1" href="#6.11.1">6.11.1 Floating types</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.1p1" href="#6.11.1p1"><small>1</small></a>
  Future standardization may include additional floating-point types, including those with
  greater range, precision, or both than long double.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.2" href="#6.11.2">6.11.2 Linkages of identifiers</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.2p1" href="#6.11.2p1"><small>1</small></a>
  Declaring an identifier with internal linkage at file scope without the static storage-
  class specifier is an obsolescent feature.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.3" href="#6.11.3">6.11.3 External names</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.3p1" href="#6.11.3p1"><small>1</small></a>
  Restriction of the significance of an external name to fewer than 255 characters
  (considering each universal character name or extended source character as a single
  character) is an obsolescent feature that is a concession to existing implementations.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.4" href="#6.11.4">6.11.4 Character escape sequences</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.4p1" href="#6.11.4p1"><small>1</small></a>
  Lowercase letters as escape sequences are reserved for future standardization. Other
  characters may be used in extensions.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.5" href="#6.11.5">6.11.5 Storage-class specifiers</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.5p1" href="#6.11.5p1"><small>1</small></a>
  The placement of a storage-class specifier other than at the beginning of the declaration
  specifiers in a declaration is an obsolescent feature.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.6" href="#6.11.6">6.11.6 Function declarators</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.6p1" href="#6.11.6p1"><small>1</small></a>
  The use of function declarators with empty parentheses (not prototype-format parameter
  type declarators) is an obsolescent feature.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.7" href="#6.11.7">6.11.7 Function definitions</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.7p1" href="#6.11.7p1"><small>1</small></a>
  The use of function definitions with separate parameter identifier and declaration lists
  (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.8" href="#6.11.8">6.11.8 Pragma directives</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.8p1" href="#6.11.8p1"><small>1</small></a>
  Pragmas whose first preprocessing token is STDC are reserved for future standardization.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="6.11.9" href="#6.11.9">6.11.9 Predefined macro names</a></h4>
-<p><!--para 1 -->
+<p><a name="6.11.9p1" href="#6.11.9p1"><small>1</small></a>
  Macro names beginning with __STDC_ are reserved for future standardization.
 <!--page 176 -->
 
@@ -8773,27 +8773,27 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.1.1" href="#7.1.1">7.1.1 Definitions of terms</a></h4>
-<p><!--para 1 -->
+<p><a name="7.1.1p1" href="#7.1.1p1"><small>1</small></a>
  A string is a contiguous sequence of characters terminated by and including the first null
  character. The term multibyte string is sometimes used instead to emphasize special
  processing given to multibyte characters contained in the string or to avoid confusion
  with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
  character. The length of a string is the number of bytes preceding the null character and
  the value of a string is the sequence of the values of the contained characters, in order.
-<p><!--para 2 -->
+<p><a name="7.1.1p2" href="#7.1.1p2"><small>2</small></a>
  The decimal-point character is the character used by functions that convert floating-point
  numbers to or from character sequences to denote the beginning of the fractional part of
  such character sequences.<sup><a href="#note157"><b>157)</b></a></sup> It is represented in the text and examples by a period, but
  may be changed by the setlocale function.
-<p><!--para 3 -->
+<p><a name="7.1.1p3" href="#7.1.1p3"><small>3</small></a>
  A null wide character is a wide character with code value zero.
-<p><!--para 4 -->
+<p><a name="7.1.1p4" href="#7.1.1p4"><small>4</small></a>
  A wide string is a contiguous sequence of wide characters terminated by and including
  the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
  addressed) wide character. The length of a wide string is the number of wide characters
  preceding the null wide character and the value of a wide string is the sequence of code
  values of the contained wide characters, in order.
-<p><!--para 5 -->
+<p><a name="7.1.1p5" href="#7.1.1p5"><small>5</small></a>
  A shift sequence is a contiguous sequence of bytes within a multibyte string that
  (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
  corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
@@ -8817,13 +8817,13 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.1.2" href="#7.1.2">7.1.2 Standard headers</a></h4>
-<p><!--para 1 -->
+<p><a name="7.1.2p1" href="#7.1.2p1"><small>1</small></a>
  Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note159"><b>159)</b></a></sup>
  whose contents are made available by the #include preprocessing directive. The
  header declares a set of related functions, plus any necessary types and additional macros
  needed to facilitate their use. Declarations of types described in this clause shall not
  include type qualifiers, unless explicitly stated otherwise.
-<p><!--para 2 -->
+<p><a name="7.1.2p2" href="#7.1.2p2"><small>2</small></a>
  The standard headers are
 <pre>
         <a href="#7.2">&lt;assert.h&gt;</a>             <a href="#7.8">&lt;inttypes.h&gt;</a>            <a href="#7.14">&lt;signal.h&gt;</a>              <a href="#7.20">&lt;stdlib.h&gt;</a>
@@ -8833,11 +8833,11 @@ unsigned long long int
         <a href="#7.6">&lt;fenv.h&gt;</a>               <a href="#7.12">&lt;math.h&gt;</a>                <a href="#7.18">&lt;stdint.h&gt;</a>              <a href="#7.24">&lt;wchar.h&gt;</a>
         <a href="#7.7">&lt;float.h&gt;</a>              <a href="#7.13">&lt;setjmp.h&gt;</a>              <a href="#7.19">&lt;stdio.h&gt;</a>               <a href="#7.25">&lt;wctype.h&gt;</a>
 </pre>
-<p><!--para 3 -->
+<p><a name="7.1.2p3" href="#7.1.2p3"><small>3</small></a>
  If a file with the same name as one of the above &lt; and &gt; delimited sequences, not
  provided as part of the implementation, is placed in any of the standard places that are
  searched for included source files, the behavior is undefined.
-<p><!--para 4 -->
+<p><a name="7.1.2p4" href="#7.1.2p4"><small>4</small></a>
  Standard headers may be included in any order; each may be included more than once in
  a given scope, with no effect different from being included only once, except that the
  effect of including <a href="#7.2">&lt;assert.h&gt;</a> depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
@@ -8848,13 +8848,13 @@ unsigned long long int
  included after the initial reference to the identifier. The program shall not have any
  macros with names lexically identical to keywords currently defined prior to the
  inclusion.
-<p><!--para 5 -->
+<p><a name="7.1.2p5" href="#7.1.2p5"><small>5</small></a>
  Any definition of an object-like macro described in this clause shall expand to code that is
  fully protected by parentheses where necessary, so that it groups in an arbitrary
  expression as if it were a single identifier.
-<p><!--para 6 -->
+<p><a name="7.1.2p6" href="#7.1.2p6"><small>6</small></a>
  Any declaration of a library function shall have external linkage.
-<p><!--para 7 -->
+<p><a name="7.1.2p7" href="#7.1.2p7"><small>7</small></a>
  A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
 <p><b> Forward references</b>: diagnostics (<a href="#7.2">7.2</a>).
  
@@ -8870,7 +8870,7 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.1.3" href="#7.1.3">7.1.3 Reserved identifiers</a></h4>
-<p><!--para 1 -->
+<p><a name="7.1.3p1" href="#7.1.3p1"><small>1</small></a>
  Each header declares or defines all identifiers listed in its associated subclause, and
  optionally declares or defines identifiers listed in its associated future library directions
  subclause and identifiers which are always reserved either for any use or for use as file
@@ -8890,11 +8890,11 @@ unsigned long long int
  future library directions) is reserved for use as a macro name and as an identifier with
  file scope in the same name space if any of its associated headers is included.
 </ul>
-<p><!--para 2 -->
+<p><a name="7.1.3p2" href="#7.1.3p2"><small>2</small></a>
  No other identifiers are reserved. If the program declares or defines an identifier in a
  context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
  identifier as a macro name, the behavior is undefined.
-<p><!--para 3 -->
+<p><a name="7.1.3p3" href="#7.1.3p3"><small>3</small></a>
  If the program removes (with #undef) any macro definition of an identifier in the first
  group listed above, the behavior is undefined.
 
@@ -8905,7 +8905,7 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.1.4" href="#7.1.4">7.1.4 Use of library functions</a></h4>
-<p><!--para 1 -->
+<p><a name="7.1.4p1" href="#7.1.4p1"><small>1</small></a>
  Each of the following statements applies unless explicitly stated otherwise in the detailed
  descriptions that follow: If an argument to a function has an invalid value (such as a value
  outside the domain of the function, or a pointer outside the address space of the program,
@@ -8933,20 +8933,20 @@ unsigned long long int
  compatible return type could be called.<sup><a href="#note163"><b>163)</b></a></sup> All object-like macros listed as expanding to
  integer constant expressions shall additionally be suitable for use in #if preprocessing
  directives.
-<p><!--para 2 -->
+<p><a name="7.1.4p2" href="#7.1.4p2"><small>2</small></a>
  Provided that a library function can be declared without reference to any type defined in a
  header, it is also permissible to declare the function and use it without including its
  associated header.
-<p><!--para 3 -->
+<p><a name="7.1.4p3" href="#7.1.4p3"><small>3</small></a>
  There is a sequence point immediately before a library function returns.
-<p><!--para 4 -->
+<p><a name="7.1.4p4" href="#7.1.4p4"><small>4</small></a>
  The functions in the standard library are not guaranteed to be reentrant and may modify
  objects with static storage duration.<sup><a href="#note164"><b>164)</b></a></sup>
  
  
  
 <!--page 180 -->
-<p><!--para 5 -->
+<p><a name="7.1.4p5" href="#7.1.4p5"><small>5</small></a>
  EXAMPLE       The function atoi may be used in any of several ways:
 <ul>
 <li>  by use of its associated header (possibly generating a macro expansion)
@@ -9011,7 +9011,7 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="7.2" href="#7.2">7.2 Diagnostics &lt;assert.h&gt;</a></h3>
-<p><!--para 1 -->
+<p><a name="7.2p1" href="#7.2p1"><small>1</small></a>
  The header <a href="#7.2">&lt;assert.h&gt;</a> defines the assert macro and refers to another macro,
 <pre>
          NDEBUG
@@ -9024,7 +9024,7 @@ unsigned long long int
 </pre>
  The assert macro is redefined according to the current state of NDEBUG each time that
  <a href="#7.2">&lt;assert.h&gt;</a> is included.
-<p><!--para 2 -->
+<p><a name="7.2p2" href="#7.2p2"><small>2</small></a>
  The assert macro shall be implemented as a macro, not as an actual function. If the
  macro definition is suppressed in order to access an actual function, the behavior is
  undefined.
@@ -9035,13 +9035,13 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.2.1.1" href="#7.2.1.1">7.2.1.1 The assert macro</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.2.1.1p1" href="#7.2.1.1p1"><small>1</small></a>
 <pre>
          #include <a href="#7.2">&lt;assert.h&gt;</a>
          void assert(scalar expression);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.2.1.1p2" href="#7.2.1.1p2"><small>2</small></a>
  The assert macro puts diagnostic tests into programs; it expands to a void expression.
  When it is executed, if expression (which shall have a scalar type) is false (that is,
  compares equal to 0), the assert macro writes information about the particular call that
@@ -9051,7 +9051,7 @@ unsigned long long int
  __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note165"><b>165)</b></a></sup> It
  then calls the abort function.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.2.1.1p3" href="#7.2.1.1p3"><small>3</small></a>
  The assert macro returns no value.
 <p><b> Forward references</b>: the abort function (<a href="#7.20.4.1">7.20.4.1</a>).
  
@@ -9070,14 +9070,14 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.3.1" href="#7.3.1">7.3.1 Introduction</a></h4>
-<p><!--para 1 -->
+<p><a name="7.3.1p1" href="#7.3.1p1"><small>1</small></a>
  The header <a href="#7.3">&lt;complex.h&gt;</a> defines macros and declares functions that support complex
  arithmetic.<sup><a href="#note166"><b>166)</b></a></sup> Each synopsis specifies a family of functions consisting of a principal
  function with one or more double complex parameters and a double complex or
  double return value; and other functions with the same name but with f and l suffixes
  which are corresponding functions with float and long double parameters and
  return values.
-<p><!--para 2 -->
+<p><a name="7.3.1p2" href="#7.3.1p2"><small>2</small></a>
  The macro
 <pre>
           complex
@@ -9088,7 +9088,7 @@ unsigned long long int
 </pre>
  expands to a constant expression of type const float _Complex, with the value of
  the imaginary unit.<sup><a href="#note167"><b>167)</b></a></sup>
-<p><!--para 3 -->
+<p><a name="7.3.1p3" href="#7.3.1p3"><small>3</small></a>
  The macros
 <pre>
           imaginary
@@ -9100,14 +9100,14 @@ unsigned long long int
  are defined if and only if the implementation supports imaginary types;<sup><a href="#note168"><b>168)</b></a></sup> if defined,
  they expand to _Imaginary and a constant expression of type const float
  _Imaginary with the value of the imaginary unit.
-<p><!--para 4 -->
+<p><a name="7.3.1p4" href="#7.3.1p4"><small>4</small></a>
  The macro
 <pre>
           I
 </pre>
  expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
  defined, I shall expand to _Complex_I.
-<p><!--para 5 -->
+<p><a name="7.3.1p5" href="#7.3.1p5"><small>5</small></a>
  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.
 <p><b> Forward references</b>: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
@@ -9126,13 +9126,13 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.3.2" href="#7.3.2">7.3.2 Conventions</a></h4>
-<p><!--para 1 -->
+<p><a name="7.3.2p1" href="#7.3.2p1"><small>1</small></a>
  Values are interpreted as radians, not degrees. An implementation may set errno but is
  not required to.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.3.3" href="#7.3.3">7.3.3 Branch cuts</a></h4>
-<p><!--para 1 -->
+<p><a name="7.3.3p1" href="#7.3.3p1"><small>1</small></a>
  Some of the functions below have branch cuts, across which the function is
  discontinuous. For implementations with a signed zero (including all IEC 60559
  implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
@@ -9141,7 +9141,7 @@ unsigned long long int
  function, which has a branch cut along the negative real axis, the top of the cut, with
  imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
  imaginary part -0, maps to the negative imaginary axis.
-<p><!--para 2 -->
+<p><a name="7.3.3p2" href="#7.3.3p2"><small>2</small></a>
  Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
  sides of branch cuts. These implementations shall map a cut so the function is continuous
  as the cut is approached coming around the finite endpoint of the cut in a counter
@@ -9153,13 +9153,13 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.3.4" href="#7.3.4">7.3.4 The CX_LIMITED_RANGE pragma</a></h4>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.4p1" href="#7.3.4p1"><small>1</small></a>
 <pre>
           #include <a href="#7.3">&lt;complex.h&gt;</a>
           #pragma STDC CX_LIMITED_RANGE on-off-switch
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.4p2" href="#7.3.4p2"><small>2</small></a>
  The usual mathematical formulas for complex multiply, divide, and absolute value are
  problematic because of their treatment of infinities and because of undue overflow and
  underflow. The CX_LIMITED_RANGE pragma can be used to inform the
@@ -9194,7 +9194,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.5.1" href="#7.3.5.1">7.3.5.1 The cacos functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.5.1p1" href="#7.3.5.1p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex cacos(double complex z);
@@ -9202,11 +9202,11 @@ unsigned long long int
         long double complex cacosl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.5.1p2" href="#7.3.5.1p2"><small>2</small></a>
  The cacos functions compute the complex arc cosine of z, with branch cuts outside the
  interval [-1, +1] along the real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.5.1p3" href="#7.3.5.1p3"><small>3</small></a>
  The cacos functions return the complex arc cosine value, in the range of a strip
  mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
  real axis.
@@ -9214,7 +9214,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.5.2" href="#7.3.5.2">7.3.5.2 The casin functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.5.2p1" href="#7.3.5.2p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex casin(double complex z);
@@ -9222,11 +9222,11 @@ unsigned long long int
         long double complex casinl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.5.2p2" href="#7.3.5.2p2"><small>2</small></a>
  The casin functions compute the complex arc sine of z, with branch cuts outside the
  interval [-1, +1] along the real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.5.2p3" href="#7.3.5.2p3"><small>3</small></a>
  The casin functions return the complex arc sine value, in the range of a strip
  mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
  along the real axis.
@@ -9235,7 +9235,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.5.3" href="#7.3.5.3">7.3.5.3 The catan functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.5.3p1" href="#7.3.5.3p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex catan(double complex z);
@@ -9243,11 +9243,11 @@ unsigned long long int
         long double complex catanl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.5.3p2" href="#7.3.5.3p2"><small>2</small></a>
  The catan functions compute the complex arc tangent of z, with branch cuts outside the
  interval [-i, +i] along the imaginary axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.5.3p3" href="#7.3.5.3p3"><small>3</small></a>
  The catan functions return the complex arc tangent value, in the range of a strip
  mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
  along the real axis.
@@ -9255,7 +9255,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.5.4" href="#7.3.5.4">7.3.5.4 The ccos functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.5.4p1" href="#7.3.5.4p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex ccos(double complex z);
@@ -9263,16 +9263,16 @@ unsigned long long int
         long double complex ccosl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.5.4p2" href="#7.3.5.4p2"><small>2</small></a>
  The ccos functions compute the complex cosine of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.5.4p3" href="#7.3.5.4p3"><small>3</small></a>
  The ccos functions return the complex cosine value.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.5.5" href="#7.3.5.5">7.3.5.5 The csin functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.5.5p1" href="#7.3.5.5p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex csin(double complex z);
@@ -9280,17 +9280,17 @@ unsigned long long int
         long double complex csinl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.5.5p2" href="#7.3.5.5p2"><small>2</small></a>
  The csin functions compute the complex sine of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.5.5p3" href="#7.3.5.5p3"><small>3</small></a>
  The csin functions return the complex sine value.
 <!--page 186 -->
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.5.6" href="#7.3.5.6">7.3.5.6 The ctan functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.5.6p1" href="#7.3.5.6p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex ctan(double complex z);
@@ -9298,10 +9298,10 @@ unsigned long long int
         long double complex ctanl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.5.6p2" href="#7.3.5.6p2"><small>2</small></a>
  The ctan functions compute the complex tangent of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.5.6p3" href="#7.3.5.6p3"><small>3</small></a>
  The ctan functions return the complex tangent value.
 
 <p><small><a href="#Contents">Contents</a></small>
@@ -9310,7 +9310,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.6.1" href="#7.3.6.1">7.3.6.1 The cacosh functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.6.1p1" href="#7.3.6.1p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex cacosh(double complex z);
@@ -9318,11 +9318,11 @@ unsigned long long int
         long double complex cacoshl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.6.1p2" href="#7.3.6.1p2"><small>2</small></a>
  The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
  cut at values less than 1 along the real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.6.1p3" href="#7.3.6.1p3"><small>3</small></a>
  The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
  half-strip of non-negative values along the real axis and in the interval [-ipi , +ipi ] along
  the imaginary axis.
@@ -9330,7 +9330,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.6.2" href="#7.3.6.2">7.3.6.2 The casinh functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.6.2p1" href="#7.3.6.2p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex casinh(double complex z);
@@ -9338,12 +9338,12 @@ unsigned long long int
         long double complex casinhl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.6.2p2" href="#7.3.6.2p2"><small>2</small></a>
  The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
  outside the interval [-i, +i] along the imaginary axis.
 <!--page 187 -->
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.6.2p3" href="#7.3.6.2p3"><small>3</small></a>
  The casinh functions return the complex arc hyperbolic sine value, in the range of a
  strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
  along the imaginary axis.
@@ -9351,7 +9351,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.6.3" href="#7.3.6.3">7.3.6.3 The catanh functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.6.3p1" href="#7.3.6.3p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex catanh(double complex z);
@@ -9359,11 +9359,11 @@ unsigned long long int
         long double complex catanhl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.6.3p2" href="#7.3.6.3p2"><small>2</small></a>
  The catanh functions compute the complex arc hyperbolic tangent of z, with branch
  cuts outside the interval [-1, +1] along the real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.6.3p3" href="#7.3.6.3p3"><small>3</small></a>
  The catanh functions return the complex arc hyperbolic tangent value, in the range of a
  strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
  along the imaginary axis.
@@ -9371,7 +9371,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.6.4" href="#7.3.6.4">7.3.6.4 The ccosh functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.6.4p1" href="#7.3.6.4p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex ccosh(double complex z);
@@ -9379,16 +9379,16 @@ unsigned long long int
         long double complex ccoshl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.6.4p2" href="#7.3.6.4p2"><small>2</small></a>
  The ccosh functions compute the complex hyperbolic cosine of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.6.4p3" href="#7.3.6.4p3"><small>3</small></a>
  The ccosh functions return the complex hyperbolic cosine value.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.6.5" href="#7.3.6.5">7.3.6.5 The csinh functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.6.5p1" href="#7.3.6.5p1"><small>1</small></a>
 <!--page 188 -->
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
@@ -9397,16 +9397,16 @@ unsigned long long int
         long double complex csinhl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.6.5p2" href="#7.3.6.5p2"><small>2</small></a>
  The csinh functions compute the complex hyperbolic sine of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.6.5p3" href="#7.3.6.5p3"><small>3</small></a>
  The csinh functions return the complex hyperbolic sine value.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.6.6" href="#7.3.6.6">7.3.6.6 The ctanh functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.6.6p1" href="#7.3.6.6p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex ctanh(double complex z);
@@ -9414,10 +9414,10 @@ unsigned long long int
         long double complex ctanhl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.6.6p2" href="#7.3.6.6p2"><small>2</small></a>
  The ctanh functions compute the complex hyperbolic tangent of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.6.6p3" href="#7.3.6.6p3"><small>3</small></a>
  The ctanh functions return the complex hyperbolic tangent value.
 
 <p><small><a href="#Contents">Contents</a></small>
@@ -9426,7 +9426,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.7.1" href="#7.3.7.1">7.3.7.1 The cexp functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.7.1p1" href="#7.3.7.1p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex cexp(double complex z);
@@ -9434,16 +9434,16 @@ unsigned long long int
         long double complex cexpl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.7.1p2" href="#7.3.7.1p2"><small>2</small></a>
  The cexp functions compute the complex base-e exponential of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.7.1p3" href="#7.3.7.1p3"><small>3</small></a>
  The cexp functions return the complex base-e exponential value.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.7.2" href="#7.3.7.2">7.3.7.2 The clog functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.7.2p1" href="#7.3.7.2p1"><small>1</small></a>
 <!--page 189 -->
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
@@ -9452,11 +9452,11 @@ unsigned long long int
         long double complex clogl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.7.2p2" href="#7.3.7.2p2"><small>2</small></a>
  The clog functions compute the complex natural (base-e) logarithm of z, with a branch
  cut along the negative real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.7.2p3" href="#7.3.7.2p3"><small>3</small></a>
  The clog functions return the complex natural logarithm value, in the range of a strip
  mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
  imaginary axis.
@@ -9467,7 +9467,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.8.1" href="#7.3.8.1">7.3.8.1 The cabs functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.8.1p1" href="#7.3.8.1p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double cabs(double complex z);
@@ -9475,17 +9475,17 @@ unsigned long long int
         long double cabsl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.8.1p2" href="#7.3.8.1p2"><small>2</small></a>
  The cabs functions compute the complex absolute value (also called norm, modulus, or
  magnitude) of z.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.8.1p3" href="#7.3.8.1p3"><small>3</small></a>
  The cabs functions return the complex absolute value.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.8.2" href="#7.3.8.2">7.3.8.2 The cpow functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.8.2p1" href="#7.3.8.2p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex cpow(double complex x, double complex y);
@@ -9494,18 +9494,18 @@ unsigned long long int
              long double complex y);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.8.2p2" href="#7.3.8.2p2"><small>2</small></a>
  The cpow functions compute the complex power function xy , with a branch cut for the
  first parameter along the negative real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.8.2p3" href="#7.3.8.2p3"><small>3</small></a>
  The cpow functions return the complex power function value.
 <!--page 190 -->
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.8.3" href="#7.3.8.3">7.3.8.3 The csqrt functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.8.3p1" href="#7.3.8.3p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex csqrt(double complex z);
@@ -9513,11 +9513,11 @@ unsigned long long int
         long double complex csqrtl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.8.3p2" href="#7.3.8.3p2"><small>2</small></a>
  The csqrt functions compute the complex square root of z, with a branch cut along the
  negative real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.8.3p3" href="#7.3.8.3p3"><small>3</small></a>
  The csqrt functions return the complex square root value, in the range of the right half-
  plane (including the imaginary axis).
 
@@ -9527,7 +9527,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.9.1" href="#7.3.9.1">7.3.9.1 The carg functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.9.1p1" href="#7.3.9.1p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double carg(double complex z);
@@ -9535,17 +9535,17 @@ unsigned long long int
         long double cargl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.9.1p2" href="#7.3.9.1p2"><small>2</small></a>
  The carg functions compute the argument (also called phase angle) of z, with a branch
  cut along the negative real axis.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.9.1p3" href="#7.3.9.1p3"><small>3</small></a>
  The carg functions return the value of the argument in the interval [-pi , +pi ].
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.9.2" href="#7.3.9.2">7.3.9.2 The cimag functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.9.2p1" href="#7.3.9.2p1"><small>1</small></a>
 <!--page 191 -->
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
@@ -9554,10 +9554,10 @@ unsigned long long int
         long double cimagl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.9.2p2" href="#7.3.9.2p2"><small>2</small></a>
  The cimag functions compute the imaginary part of z.<sup><a href="#note170"><b>170)</b></a></sup>
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.9.2p3" href="#7.3.9.2p3"><small>3</small></a>
  The cimag functions return the imaginary part value (as a real).
 
 <p><b>Footnotes</b>
@@ -9567,7 +9567,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.9.3" href="#7.3.9.3">7.3.9.3 The conj functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.9.3p1" href="#7.3.9.3p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex conj(double complex z);
@@ -9575,17 +9575,17 @@ unsigned long long int
         long double complex conjl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.9.3p2" href="#7.3.9.3p2"><small>2</small></a>
  The conj functions compute the complex conjugate of z, by reversing the sign of its
  imaginary part.
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.9.3p3" href="#7.3.9.3p3"><small>3</small></a>
  The conj functions return the complex conjugate value.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.9.4" href="#7.3.9.4">7.3.9.4 The cproj functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.9.4p1" href="#7.3.9.4p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double complex cproj(double complex z);
@@ -9593,7 +9593,7 @@ unsigned long long int
         long double complex cprojl(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.9.4p2" href="#7.3.9.4p2"><small>2</small></a>
  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
@@ -9602,7 +9602,7 @@ unsigned long long int
         INFINITY + I * copysign(0.0, cimag(z))
 </pre>
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.9.4p3" href="#7.3.9.4p3"><small>3</small></a>
  The cproj functions return the value of the projection onto the Riemann sphere.
  
  
@@ -9613,7 +9613,7 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.3.9.5" href="#7.3.9.5">7.3.9.5 The creal functions</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.3.9.5p1" href="#7.3.9.5p1"><small>1</small></a>
 <pre>
         #include <a href="#7.3">&lt;complex.h&gt;</a>
         double creal(double complex z);
@@ -9621,10 +9621,10 @@ unsigned long long int
         long double creall(long double complex z);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.3.9.5p2" href="#7.3.9.5p2"><small>2</small></a>
  The creal functions compute the real part of z.<sup><a href="#note171"><b>171)</b></a></sup>
 <p><b>Returns</b>
-<p><!--para 3 -->
+<p><a name="7.3.9.5p3" href="#7.3.9.5p3"><small>3</small></a>
  The creal functions return the real part value.
  
  
@@ -9638,15 +9638,15 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h3><a name="7.4" href="#7.4">7.4 Character handling &lt;ctype.h&gt;</a></h3>
-<p><!--para 1 -->
+<p><a name="7.4p1" href="#7.4p1"><small>1</small></a>
  The header <a href="#7.4">&lt;ctype.h&gt;</a> declares several functions useful for classifying and mapping
  characters.<sup><a href="#note172"><b>172)</b></a></sup> In all cases the argument is an int, the value of which shall be
  representable as an unsigned char or shall equal the value of the macro EOF. If the
  argument has any other value, the behavior is undefined.
-<p><!--para 2 -->
+<p><a name="7.4p2" href="#7.4p2"><small>2</small></a>
  The behavior of these functions is affected by the current locale. Those functions that
  have locale-specific aspects only when not in the "C" locale are noted below.
-<p><!--para 3 -->
+<p><a name="7.4p3" href="#7.4p3"><small>3</small></a>
  The term printing character refers to a member of a locale-specific set of characters, each
  of which occupies one printing position on a display device; the term control character
  refers to a member of a locale-specific set of characters that are not printing
@@ -9663,32 +9663,32 @@ unsigned long long int
 
 <p><small><a href="#Contents">Contents</a></small>
 <h4><a name="7.4.1" href="#7.4.1">7.4.1 Character classification functions</a></h4>
-<p><!--para 1 -->
+<p><a name="7.4.1p1" href="#7.4.1p1"><small>1</small></a>
  The functions in this subclause return nonzero (true) if and only if the value of the
  argument c conforms to that in the description of the function.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.4.1.1" href="#7.4.1.1">7.4.1.1 The isalnum function</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.4.1.1p1" href="#7.4.1.1p1"><small>1</small></a>
 <pre>
           #include <a href="#7.4">&lt;ctype.h&gt;</a>
           int isalnum(int c);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.4.1.1p2" href="#7.4.1.1p2"><small>2</small></a>
  The isalnum function tests for any character for which isalpha or isdigit is true.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.4.1.2" href="#7.4.1.2">7.4.1.2 The isalpha function</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.4.1.2p1" href="#7.4.1.2p1"><small>1</small></a>
 <pre>
           #include <a href="#7.4">&lt;ctype.h&gt;</a>
           int isalpha(int c);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.4.1.2p2" href="#7.4.1.2p2"><small>2</small></a>
  The isalpha function tests for any character for which isupper or islower is true,
  or any character that is one of a locale-specific set of alphabetic characters for which
  
@@ -9706,13 +9706,13 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.4.1.3" href="#7.4.1.3">7.4.1.3 The isblank function</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.4.1.3p1" href="#7.4.1.3p1"><small>1</small></a>
 <pre>
          #include <a href="#7.4">&lt;ctype.h&gt;</a>
          int isblank(int c);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.4.1.3p2" href="#7.4.1.3p2"><small>2</small></a>
  The isblank function tests for any character that is a standard blank character or is one
  of a locale-specific set of characters for which isspace is true and that is used to
  separate words within a line of text. The standard blank characters are the following:
@@ -9722,31 +9722,31 @@ unsigned long long int
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.4.1.4" href="#7.4.1.4">7.4.1.4 The iscntrl function</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.4.1.4p1" href="#7.4.1.4p1"><small>1</small></a>
 <pre>
          #include <a href="#7.4">&lt;ctype.h&gt;</a>
          int iscntrl(int c);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.4.1.4p2" href="#7.4.1.4p2"><small>2</small></a>
  The iscntrl function tests for any control character.
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.4.1.5" href="#7.4.1.5">7.4.1.5 The isdigit function</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.4.1.5p1" href="#7.4.1.5p1"><small>1</small></a>
 <pre>
          #include <a href="#7.4">&lt;ctype.h&gt;</a>
          int isdigit(int c);
 </pre>
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.4.1.5p2" href="#7.4.1.5p2"><small>2</small></a>
  The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
 
 <p><small><a href="#Contents">Contents</a></small>
 <h5><a name="7.4.1.6" href="#7.4.1.6">7.4.1.6 The isgraph function</a></h5>
 <p><b>Synopsis</b>
-<p><!--para 1 -->
+<p><a name="7.4.1.6p1" href="#7.4.1.6p1"><small>1</small></a>
 <pre>
          #include <a href="#7.4">&lt;ctype.h&gt;</a>
          int isgraph(int c);
@@ -9757,19 +9757,19 @@ unsigned long long int
  
 <!--page 195 -->
 <p><b>Description</b>
-<p><!--para 2 -->
+<p><a name="7.4.1.6p2" href="#7.4.1.6p2"><small>2</small></a>
  The isgraph function tests for any printing character except space (' ').
 
 <p><small&g