--- oldlibc.html	2004-03-25 22:19:59.352059408 -0600
+++ libc.html	2004-03-25 22:13:13.441767152 -0600
@@ -22,1299 +22,1299 @@
 of the GNU C Library.
 
 <ul>
 <li><a accesskey=1 href="#Introduction">Introduction</a>:                  Purpose of the GNU C Library. 
-<li><a accesskey=2 href="#Error%20Reporting">Error Reporting</a>:               How library functions report errors. 
+<li><a accesskey=2 href="#Error Reporting">Error Reporting</a>:               How library functions report errors. 
 <li><a accesskey=3 href="#Memory">Memory</a>:                        Allocating virtual memory and controlling
                                    paging. 
-<li><a accesskey=4 href="#Character%20Handling">Character Handling</a>:            Character testing and conversion functions. 
-<li><a accesskey=5 href="#String%20and%20Array%20Utilities">String and Array Utilities</a>:    Utilities for copying and comparing strings
+<li><a accesskey=4 href="#Character Handling">Character Handling</a>:            Character testing and conversion functions. 
+<li><a accesskey=5 href="#String and Array Utilities">String and Array Utilities</a>:    Utilities for copying and comparing strings
                                    and arrays. 
-<li><a accesskey=6 href="#Character%20Set%20Handling">Character Set Handling</a>:        Support for extended character sets. 
+<li><a accesskey=6 href="#Character Set Handling">Character Set Handling</a>:        Support for extended character sets. 
 <li><a accesskey=7 href="#Locales">Locales</a>:                       The country and language can affect the
                                    behavior of library functions. 
-<li><a accesskey=8 href="#Message%20Translation">Message Translation</a>:           How to make the program speak the user's
+<li><a accesskey=8 href="#Message Translation">Message Translation</a>:           How to make the program speak the user's
                                    language. 
-<li><a accesskey=9 href="#Searching%20and%20Sorting">Searching and Sorting</a>:         General searching and sorting functions. 
-<li><a href="#Pattern%20Matching">Pattern Matching</a>:              Matching shell ``globs'' and regular
+<li><a accesskey=9 href="#Searching and Sorting">Searching and Sorting</a>:         General searching and sorting functions. 
+<li><a href="#Pattern Matching">Pattern Matching</a>:              Matching shell "globs" and regular
                                    expressions. 
-<li><a href="#I%2fO%20Overview">I/O Overview</a>:                  Introduction to the I/O facilities. 
-<li><a href="#I%2fO%20on%20Streams">I/O on Streams</a>:                High-level, portable I/O facilities. 
-<li><a href="#Low-Level%20I%2fO">Low-Level I/O</a>:                 Low-level, less portable I/O. 
-<li><a href="#File%20System%20Interface">File System Interface</a>:         Functions for manipulating files. 
-<li><a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>:               A simple interprocess communication
+<li><a href="#I%2fO Overview">I/O Overview</a>:                  Introduction to the I/O facilities. 
+<li><a href="#I%2fO on Streams">I/O on Streams</a>:                High-level, portable I/O facilities. 
+<li><a href="#Low-Level I%2fO">Low-Level I/O</a>:                 Low-level, less portable I/O. 
+<li><a href="#File System Interface">File System Interface</a>:         Functions for manipulating files. 
+<li><a href="#Pipes and FIFOs">Pipes and FIFOs</a>:               A simple interprocess communication
                                    mechanism. 
 <li><a href="#Sockets">Sockets</a>:                       A more complicated IPC mechanism, with
                                    networking support. 
-<li><a href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>:  How to change the characteristics of a
+<li><a href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>:  How to change the characteristics of a
                                    terminal device. 
 <li><a href="#Syslog">Syslog</a>:                        System logging and messaging. 
 <li><a href="#Mathematics">Mathematics</a>:                   Math functions, useful constants, random
                                    numbers. 
 <li><a href="#Arithmetic">Arithmetic</a>:                    Low level arithmetic functions. 
-<li><a href="#Date%20and%20Time">Date and Time</a>:                 Functions for getting the date and time and
+<li><a href="#Date and Time">Date and Time</a>:                 Functions for getting the date and time and
                                    formatting them nicely. 
-<li><a href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>:  Functions for examining resource usage and
+<li><a href="#Resource Usage And Limitation">Resource Usage And Limitation</a>:  Functions for examining resource usage and
                                    getting and setting limits. 
-<li><a href="#Non-Local%20Exits">Non-Local Exits</a>:               Jumping out of nested function calls. 
-<li><a href="#Signal%20Handling">Signal Handling</a>:               How to send, block, and handle signals. 
-<li><a href="#Program%20Basics">Program Basics</a>:                Writing the beginning and end of your
+<li><a href="#Non-Local Exits">Non-Local Exits</a>:               Jumping out of nested function calls. 
+<li><a href="#Signal Handling">Signal Handling</a>:               How to send, block, and handle signals. 
+<li><a href="#Program Basics">Program Basics</a>:                Writing the beginning and end of your
                                    program. 
 <li><a href="#Processes">Processes</a>:                     How to create processes and run other
                                    programs. 
-<li><a href="#Job%20Control">Job Control</a>:                   All about process groups and sessions. 
-<li><a href="#Name%20Service%20Switch">Name Service Switch</a>:           Accessing system databases. 
-<li><a href="#Users%20and%20Groups">Users and Groups</a>:              How users are identified and classified. 
-<li><a href="#System%20Management">System Management</a>:             Controlling the system and getting
+<li><a href="#Job Control">Job Control</a>:                   All about process groups and sessions. 
+<li><a href="#Name Service Switch">Name Service Switch</a>:           Accessing system databases. 
+<li><a href="#Users and Groups">Users and Groups</a>:              How users are identified and classified. 
+<li><a href="#System Management">System Management</a>:             Controlling the system and getting
                                    information about it. 
-<li><a href="#System%20Configuration">System Configuration</a>:          Parameters describing operating system
+<li><a href="#System Configuration">System Configuration</a>:          Parameters describing operating system
                                    limits. 
-<li><a href="#Cryptographic%20Functions">Cryptographic Functions</a>:       DES encryption and password handling. 
-<li><a href="#Debugging%20Support">Debugging Support</a>:             Functions to help debugging applications..
+<li><a href="#Cryptographic Functions">Cryptographic Functions</a>:       DES encryption and password handling. 
+<li><a href="#Debugging Support">Debugging Support</a>:             Functions to help debugging applications..
 
 <p>Appendices
 
-</p><li><a href="#Language%20Features">Language Features</a>:             C language features provided by the library. 
-<li><a href="#Library%20Summary">Library Summary</a>:               A summary showing the syntax, header file,
+</p><li><a href="#Language Features">Language Features</a>:             C language features provided by the library. 
+<li><a href="#Library Summary">Library Summary</a>:               A summary showing the syntax, header file,
                                    and derivation of each library feature. 
 <li><a href="#Installation">Installation</a>:                  How to install the GNU C library. 
 <li><a href="#Maintenance">Maintenance</a>:                   How to enhance and port the GNU C Library. 
 <li><a href="#Contributors">Contributors</a>:                  Who wrote what parts of the GNU C library. 
-<li><a href="#Free%20Manuals">Free Manuals</a>: 		 Free Software Needs Free Documentation. 
+<li><a href="#Free Manuals">Free Manuals</a>: 		 Free Software Needs Free Documentation. 
 <li><a href="#Copying">Copying</a>:                       The GNU Lesser General Public License says
                                   how you can copy and share the GNU C Library. 
-<li><a href="#Documentation%20License">Documentation License</a>:         This manual is under the GNU Free
+<li><a href="#Documentation License">Documentation License</a>:         This manual is under the GNU Free
                                   Documentation License.
 
 <p>Indices
 
-</p><li><a href="#Concept%20Index">Concept Index</a>:                 Index of concepts and names. 
-<li><a href="#Type%20Index">Type Index</a>:                    Index of types and type qualifiers. 
-<li><a href="#Function%20Index">Function Index</a>:                Index of functions and function-like macros. 
-<li><a href="#Variable%20Index">Variable Index</a>:                Index of variables and variable-like macros. 
-<li><a href="#File%20Index">File Index</a>:                    Index of programs and files.
+</p><li><a href="#Concept Index">Concept Index</a>:                 Index of concepts and names. 
+<li><a href="#Type Index">Type Index</a>:                    Index of types and type qualifiers. 
+<li><a href="#Function Index">Function Index</a>:                Index of functions and function-like macros. 
+<li><a href="#Variable Index">Variable Index</a>:                Index of variables and variable-like macros. 
+<li><a href="#File Index">File Index</a>:                    Index of programs and files.
 
 <p>--- The Detailed Node Listing ---
 
 <p>Introduction
 
-</p><li><a href="#Getting%20Started">Getting Started</a>:              What this manual is for and how to use it. 
-<li><a href="#Standards%20and%20Portability">Standards and Portability</a>:    Standards and sources upon which the GNU
+</p><li><a href="#Getting Started">Getting Started</a>:              What this manual is for and how to use it. 
+<li><a href="#Standards and Portability">Standards and Portability</a>:    Standards and sources upon which the GNU
                                  C library is based. 
-<li><a href="#Using%20the%20Library">Using the Library</a>:            Some practical uses for the library. 
-<li><a href="#Roadmap%20to%20the%20Manual">Roadmap to the Manual</a>:        Overview of the remaining chapters in
+<li><a href="#Using the Library">Using the Library</a>:            Some practical uses for the library. 
+<li><a href="#Roadmap to the Manual">Roadmap to the Manual</a>:        Overview of the remaining chapters in
                                  this manual.
 
 <p>Standards and Portability
 
-</p><li><a href="#ISO%20C">ISO C</a>:                        The international standard for the C
+</p><li><a href="#ISO C">ISO C</a>:                        The international standard for the C
                                  programming language. 
 <li><a href="#POSIX">POSIX</a>:                        The ISO/IEC 9945 (aka IEEE 1003) standards
                                  for operating systems. 
-<li><a href="#Berkeley%20Unix">Berkeley Unix</a>:                BSD and SunOS. 
+<li><a href="#Berkeley Unix">Berkeley Unix</a>:                BSD and SunOS. 
 <li><a href="#SVID">SVID</a>:                         The System V Interface Description. 
 <li><a href="#XPG">XPG</a>:                          The X/Open Portability Guide.
 
 <p>Using the Library
 
-</p><li><a href="#Header%20Files">Header Files</a>:                 How to include the header files in your
+</p><li><a href="#Header Files">Header Files</a>:                 How to include the header files in your
                                  programs. 
-<li><a href="#Macro%20Definitions">Macro Definitions</a>:            Some functions in the library may really
+<li><a href="#Macro Definitions">Macro Definitions</a>:            Some functions in the library may really
                                  be implemented as macros. 
-<li><a href="#Reserved%20Names">Reserved Names</a>:               The C standard reserves some names for
+<li><a href="#Reserved Names">Reserved Names</a>:               The C standard reserves some names for
                                  the library, and some for users. 
-<li><a href="#Feature%20Test%20Macros">Feature Test Macros</a>:          How to control what names are defined.
+<li><a href="#Feature Test Macros">Feature Test Macros</a>:          How to control what names are defined.
 
 <p>Error Reporting
 
-</p><li><a href="#Checking%20for%20Errors">Checking for Errors</a>:          How errors are reported by library functions. 
-<li><a href="#Error%20Codes">Error Codes</a>:                  Error code macros; all of these expand
+</p><li><a href="#Checking for Errors">Checking for Errors</a>:          How errors are reported by library functions. 
+<li><a href="#Error Codes">Error Codes</a>:                  Error code macros; all of these expand
                                  into integer constant values. 
-<li><a href="#Error%20Messages">Error Messages</a>:               Mapping error codes onto error messages.
+<li><a href="#Error Messages">Error Messages</a>:               Mapping error codes onto error messages.
 
 <p>Memory
 
-</p><li><a href="#Memory%20Concepts">Memory Concepts</a>:              An introduction to concepts and terminology. 
-<li><a href="#Memory%20Allocation">Memory Allocation</a>:            Allocating storage for your program data
-<li><a href="#Locking%20Pages">Locking Pages</a>:                Preventing page faults
-<li><a href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>:    <code>brk</code>, <code>sbrk</code>
+</p><li><a href="#Memory Concepts">Memory Concepts</a>:              An introduction to concepts and terminology. 
+<li><a href="#Memory Allocation">Memory Allocation</a>:            Allocating storage for your program data
+<li><a href="#Locking Pages">Locking Pages</a>:                Preventing page faults
+<li><a href="#Resizing the Data Segment">Resizing the Data Segment</a>:    <code>brk</code>, <code>sbrk</code>
 
 <p>Memory Allocation
 
-</p><li><a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>:      How to get different kinds of allocation in C. 
-<li><a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>:     The <code>malloc</code> facility allows fully general
+</p><li><a href="#Memory Allocation and C">Memory Allocation and C</a>:      How to get different kinds of allocation in C. 
+<li><a href="#Unconstrained Allocation">Unconstrained Allocation</a>:     The <code>malloc</code> facility allows fully general
 		 		 dynamic allocation. 
-<li><a href="#Allocation%20Debugging">Allocation Debugging</a>:         Finding memory leaks and not freed memory. 
+<li><a href="#Allocation Debugging">Allocation Debugging</a>:         Finding memory leaks and not freed memory. 
 <li><a href="#Obstacks">Obstacks</a>:                     Obstacks are less general than malloc
 				 but more efficient and convenient. 
-<li><a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>:      Allocation of variable-sized blocks
+<li><a href="#Variable Size Automatic">Variable Size Automatic</a>:      Allocation of variable-sized blocks
 				 of automatic storage that are freed when the
 				 calling function returns.
 
 <p>Unconstrained Allocation
 
-</p><li><a href="#Basic%20Allocation">Basic Allocation</a>:             Simple use of <code>malloc</code>. 
-<li><a href="#Malloc%20Examples">Malloc Examples</a>:              Examples of <code>malloc</code>.  <code>xmalloc</code>. 
-<li><a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>:         Use <code>free</code> to free a block you
+</p><li><a href="#Basic Allocation">Basic Allocation</a>:             Simple use of <code>malloc</code>. 
+<li><a href="#Malloc Examples">Malloc Examples</a>:              Examples of <code>malloc</code>.  <code>xmalloc</code>. 
+<li><a href="#Freeing after Malloc">Freeing after Malloc</a>:         Use <code>free</code> to free a block you
 				 got with <code>malloc</code>. 
-<li><a href="#Changing%20Block%20Size">Changing Block Size</a>:          Use <code>realloc</code> to make a block
+<li><a href="#Changing Block Size">Changing Block Size</a>:          Use <code>realloc</code> to make a block
 				 bigger or smaller. 
-<li><a href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>:     Use <code>calloc</code> to allocate a
+<li><a href="#Allocating Cleared Space">Allocating Cleared Space</a>:     Use <code>calloc</code> to allocate a
 				 block and clear it. 
-<li><a href="#Efficiency%20and%20Malloc">Efficiency and Malloc</a>:        Efficiency considerations in use of
+<li><a href="#Efficiency and Malloc">Efficiency and Malloc</a>:        Efficiency considerations in use of
 				 these functions. 
-<li><a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>:        Allocating specially aligned memory. 
-<li><a href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>:    Use <code>mallopt</code> to adjust allocation
+<li><a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>:        Allocating specially aligned memory. 
+<li><a href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>:    Use <code>mallopt</code> to adjust allocation
                                  parameters. 
-<li><a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>:    Automatic checking for errors. 
-<li><a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>:             You can use these hooks for debugging
+<li><a href="#Heap Consistency Checking">Heap Consistency Checking</a>:    Automatic checking for errors. 
+<li><a href="#Hooks for Malloc">Hooks for Malloc</a>:             You can use these hooks for debugging
 				 programs that use <code>malloc</code>. 
-<li><a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>:         Getting information about how much
+<li><a href="#Statistics of Malloc">Statistics of Malloc</a>:         Getting information about how much
 				 memory your program is using. 
-<li><a href="#Summary%20of%20Malloc">Summary of Malloc</a>:            Summary of <code>malloc</code> and related functions.
+<li><a href="#Summary of Malloc">Summary of Malloc</a>:            Summary of <code>malloc</code> and related functions.
 
 <p>Allocation Debugging
 
-</p><li><a href="#Tracing%20malloc">Tracing malloc</a>:                How to install the tracing functionality. 
-<li><a href="#Using%20the%20Memory%20Debugger">Using the Memory Debugger</a>:     Example programs excerpts. 
-<li><a href="#Tips%20for%20the%20Memory%20Debugger">Tips for the Memory Debugger</a>:  Some more or less clever ideas. 
-<li><a href="#Interpreting%20the%20traces">Interpreting the traces</a>:       What do all these lines mean?
+</p><li><a href="#Tracing malloc">Tracing malloc</a>:                How to install the tracing functionality. 
+<li><a href="#Using the Memory Debugger">Using the Memory Debugger</a>:     Example programs excerpts. 
+<li><a href="#Tips for the Memory Debugger">Tips for the Memory Debugger</a>:  Some more or less clever ideas. 
+<li><a href="#Interpreting the traces">Interpreting the traces</a>:       What do all these lines mean?
 
 <p>Obstacks
 
-</p><li><a href="#Creating%20Obstacks">Creating Obstacks</a>: 		How to declare an obstack in your program. 
-<li><a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>: 	Preparations needed before you can
+</p><li><a href="#Creating Obstacks">Creating Obstacks</a>: 		How to declare an obstack in your program. 
+<li><a href="#Preparing for Obstacks">Preparing for Obstacks</a>: 	Preparations needed before you can
 				 use obstacks. 
-<li><a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>:     Allocating objects in an obstack. 
-<li><a href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>:      Freeing objects in an obstack. 
-<li><a href="#Obstack%20Functions">Obstack Functions</a>: 		The obstack functions are both
+<li><a href="#Allocation in an Obstack">Allocation in an Obstack</a>:     Allocating objects in an obstack. 
+<li><a href="#Freeing Obstack Objects">Freeing Obstack Objects</a>:      Freeing objects in an obstack. 
+<li><a href="#Obstack Functions">Obstack Functions</a>: 		The obstack functions are both
 				 functions and macros. 
-<li><a href="#Growing%20Objects">Growing Objects</a>:              Making an object bigger by stages. 
-<li><a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>: 		Extra-high-efficiency (though more
+<li><a href="#Growing Objects">Growing Objects</a>:              Making an object bigger by stages. 
+<li><a href="#Extra Fast Growing">Extra Fast Growing</a>: 		Extra-high-efficiency (though more
 				 complicated) growing objects. 
-<li><a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>:         Inquiries about the status of an obstack. 
-<li><a href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>:      Controlling alignment of objects in obstacks. 
-<li><a href="#Obstack%20Chunks">Obstack Chunks</a>:               How obstacks obtain and release chunks;
+<li><a href="#Status of an Obstack">Status of an Obstack</a>:         Inquiries about the status of an obstack. 
+<li><a href="#Obstacks Data Alignment">Obstacks Data Alignment</a>:      Controlling alignment of objects in obstacks. 
+<li><a href="#Obstack Chunks">Obstack Chunks</a>:               How obstacks obtain and release chunks;
 				 efficiency considerations. 
-<li><a href="#Summary%20of%20Obstacks">Summary of Obstacks</a>:
+<li><a href="#Summary of Obstacks">Summary of Obstacks</a>:
 
 <p>Variable Size Automatic
 
-</p><li><a href="#Alloca%20Example">Alloca Example</a>:               Example of using <code>alloca</code>. 
-<li><a href="#Advantages%20of%20Alloca">Advantages of Alloca</a>:         Reasons to use <code>alloca</code>. 
-<li><a href="#Disadvantages%20of%20Alloca">Disadvantages of Alloca</a>:      Reasons to avoid <code>alloca</code>. 
-<li><a href="#GNU%20C%20Variable-Size%20Arrays">GNU C Variable-Size Arrays</a>:   Only in GNU C, here is an alternative
+</p><li><a href="#Alloca Example">Alloca Example</a>:               Example of using <code>alloca</code>. 
+<li><a href="#Advantages of Alloca">Advantages of Alloca</a>:         Reasons to use <code>alloca</code>. 
+<li><a href="#Disadvantages of Alloca">Disadvantages of Alloca</a>:      Reasons to avoid <code>alloca</code>. 
+<li><a href="#GNU C Variable-Size Arrays">GNU C Variable-Size Arrays</a>:   Only in GNU C, here is an alternative
 				 method of allocating dynamically and
 				 freeing automatically.
 
 <p>Locking Pages
 
-</p><li><a href="#Why%20Lock%20Pages">Why Lock Pages</a>:                 Reasons to read this section. 
-<li><a href="#Locked%20Memory%20Details">Locked Memory Details</a>:          Everything you need to know locked
+</p><li><a href="#Why Lock Pages">Why Lock Pages</a>:                 Reasons to read this section. 
+<li><a href="#Locked Memory Details">Locked Memory Details</a>:          Everything you need to know locked
                                     memory
-<li><a href="#Page%20Lock%20Functions">Page Lock Functions</a>:            Here's how to do it.
+<li><a href="#Page Lock Functions">Page Lock Functions</a>:            Here's how to do it.
 
 <p>Character Handling
 
-</p><li><a href="#Classification%20of%20Characters">Classification of Characters</a>:        Testing whether characters are
+</p><li><a href="#Classification of Characters">Classification of Characters</a>:        Testing whether characters are
 			                letters, digits, punctuation, etc.
 
 <p>
-</p><li><a href="#Case%20Conversion">Case Conversion</a>:                     Case mapping, and the like. 
-<li><a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>:   Character class determination for
+</p><li><a href="#Case Conversion">Case Conversion</a>:                     Case mapping, and the like. 
+<li><a href="#Classification of Wide Characters">Classification of Wide Characters</a>:   Character class determination for
                                         wide characters. 
-<li><a href="#Using%20Wide%20Char%20Classes">Using Wide Char Classes</a>:             Notes on using the wide character
+<li><a href="#Using Wide Char Classes">Using Wide Char Classes</a>:             Notes on using the wide character
                                         classes. 
-<li><a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>:      Mapping of wide characters.
+<li><a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>:      Mapping of wide characters.
 
 <p>String and Array Utilities
 
-</p><li><a href="#Representation%20of%20Strings">Representation of Strings</a>:    Introduction to basic concepts. 
-<li><a href="#String%2fArray%20Conventions">String/Array Conventions</a>:     Whether to use a string function or an
+</p><li><a href="#Representation of Strings">Representation of Strings</a>:    Introduction to basic concepts. 
+<li><a href="#String%2fArray Conventions">String/Array Conventions</a>:     Whether to use a string function or an
 				 arbitrary array function. 
-<li><a href="#String%20Length">String Length</a>:                Determining the length of a string. 
-<li><a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>:    Functions to copy the contents of strings
+<li><a href="#String Length">String Length</a>:                Determining the length of a string. 
+<li><a href="#Copying and Concatenation">Copying and Concatenation</a>:    Functions to copy the contents of strings
 				 and arrays. 
-<li><a href="#String%2fArray%20Comparison">String/Array Comparison</a>:      Functions for byte-wise and character-wise
+<li><a href="#String%2fArray Comparison">String/Array Comparison</a>:      Functions for byte-wise and character-wise
 				 comparison. 
-<li><a href="#Collation%20Functions">Collation Functions</a>:          Functions for collating strings. 
-<li><a href="#Search%20Functions">Search Functions</a>:             Searching for a specific element or substring. 
-<li><a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>:   Splitting a string into tokens by looking
+<li><a href="#Collation Functions">Collation Functions</a>:          Functions for collating strings. 
+<li><a href="#Search Functions">Search Functions</a>:             Searching for a specific element or substring. 
+<li><a href="#Finding Tokens in a String">Finding Tokens in a String</a>:   Splitting a string into tokens by looking
 				 for delimiters. 
 <li><a href="#strfry">strfry</a>:                       Function for flash-cooking a string. 
-<li><a href="#Trivial%20Encryption">Trivial Encryption</a>:           Obscuring data. 
-<li><a href="#Encode%20Binary%20Data">Encode Binary Data</a>:           Encoding and Decoding of Binary Data. 
-<li><a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>:        Null-separated string vectors.
+<li><a href="#Trivial Encryption">Trivial Encryption</a>:           Obscuring data. 
+<li><a href="#Encode Binary Data">Encode Binary Data</a>:           Encoding and Decoding of Binary Data. 
+<li><a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>:        Null-separated string vectors.
 
 <p>Argz and Envz Vectors
 
-</p><li><a href="#Argz%20Functions">Argz Functions</a>:               Operations on argz vectors. 
-<li><a href="#Envz%20Functions">Envz Functions</a>:               Additional operations on environment vectors.
+</p><li><a href="#Argz Functions">Argz Functions</a>:               Operations on argz vectors. 
+<li><a href="#Envz Functions">Envz Functions</a>:               Additional operations on environment vectors.
 
 <p>Character Set Handling
 
-</p><li><a href="#Extended%20Char%20Intro">Extended Char Intro</a>:               Introduction to Extended Characters. 
-<li><a href="#Charset%20Function%20Overview">Charset Function Overview</a>:         Overview about Character Handling
+</p><li><a href="#Extended Char Intro">Extended Char Intro</a>:               Introduction to Extended Characters. 
+<li><a href="#Charset Function Overview">Charset Function Overview</a>:         Overview about Character Handling
                                       Functions. 
-<li><a href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>:  Restartable multibyte conversion
+<li><a href="#Restartable multibyte conversion">Restartable multibyte conversion</a>:  Restartable multibyte conversion
                                       Functions. 
-<li><a href="#Non-reentrant%20Conversion">Non-reentrant Conversion</a>:          Non-reentrant Conversion Function. 
-<li><a href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>:        Generic Charset Conversion.
+<li><a href="#Non-reentrant Conversion">Non-reentrant Conversion</a>:          Non-reentrant Conversion Function. 
+<li><a href="#Generic Charset Conversion">Generic Charset Conversion</a>:        Generic Charset Conversion.
 
 <p>Restartable multibyte conversion
 
-</p><li><a href="#Selecting%20the%20Conversion">Selecting the Conversion</a>:      Selecting the conversion and its properties. 
-<li><a href="#Keeping%20the%20state">Keeping the state</a>:             Representing the state of the conversion. 
-<li><a href="#Converting%20a%20Character">Converting a Character</a>:        Converting Single Characters. 
-<li><a href="#Converting%20Strings">Converting Strings</a>:            Converting Multibyte and Wide Character
+</p><li><a href="#Selecting the Conversion">Selecting the Conversion</a>:      Selecting the conversion and its properties. 
+<li><a href="#Keeping the state">Keeping the state</a>:             Representing the state of the conversion. 
+<li><a href="#Converting a Character">Converting a Character</a>:        Converting Single Characters. 
+<li><a href="#Converting Strings">Converting Strings</a>:            Converting Multibyte and Wide Character
                                   Strings. 
-<li><a href="#Multibyte%20Conversion%20Example">Multibyte Conversion Example</a>:  A Complete Multibyte Conversion Example.
+<li><a href="#Multibyte Conversion Example">Multibyte Conversion Example</a>:  A Complete Multibyte Conversion Example.
 
 <p>Non-reentrant Conversion
 
-</p><li><a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>:   Non-reentrant Conversion of Single
+</p><li><a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>:   Non-reentrant Conversion of Single
                                          Characters. 
-<li><a href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>:      Non-reentrant Conversion of Strings. 
-<li><a href="#Shift%20State">Shift State</a>:                          States in Non-reentrant Functions.
+<li><a href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>:      Non-reentrant Conversion of Strings. 
+<li><a href="#Shift State">Shift State</a>:                          States in Non-reentrant Functions.
 
 <p>Generic Charset Conversion
 
-</p><li><a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>:     Generic Character Set Conversion Interface. 
-<li><a href="#iconv%20Examples">iconv Examples</a>:                   A complete <code>iconv</code> example. 
-<li><a href="#Other%20iconv%20Implementations">Other iconv Implementations</a>:      Some Details about other <code>iconv</code>
+</p><li><a href="#Generic Conversion Interface">Generic Conversion Interface</a>:     Generic Character Set Conversion Interface. 
+<li><a href="#iconv Examples">iconv Examples</a>:                   A complete <code>iconv</code> example. 
+<li><a href="#Other iconv Implementations">Other iconv Implementations</a>:      Some Details about other <code>iconv</code>
                                      Implementations. 
-<li><a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>:       The <code>iconv</code> Implementation in the GNU C
+<li><a href="#glibc iconv Implementation">glibc iconv Implementation</a>:       The <code>iconv</code> Implementation in the GNU C
                                      library.
 
 <p>Locales
 
-</p><li><a href="#Effects%20of%20Locale">Effects of Locale</a>:            Actions affected by the choice of
+</p><li><a href="#Effects of Locale">Effects of Locale</a>:            Actions affected by the choice of
                                  locale. 
-<li><a href="#Choosing%20Locale">Choosing Locale</a>:              How the user specifies a locale. 
-<li><a href="#Locale%20Categories">Locale Categories</a>:            Different purposes for which you can
+<li><a href="#Choosing Locale">Choosing Locale</a>:              How the user specifies a locale. 
+<li><a href="#Locale Categories">Locale Categories</a>:            Different purposes for which you can
                                  select a locale. 
-<li><a href="#Setting%20the%20Locale">Setting the Locale</a>:           How a program specifies the locale
+<li><a href="#Setting the Locale">Setting the Locale</a>:           How a program specifies the locale
                                  with library functions. 
-<li><a href="#Standard%20Locales">Standard Locales</a>:             Locale names available on all systems. 
-<li><a href="#Locale%20Information">Locale Information</a>:           How to access the information for the locale. 
-<li><a href="#Formatting%20Numbers">Formatting Numbers</a>:           A dedicated function to format numbers. 
-<li><a href="#Yes-or-No%20Questions">Yes-or-No Questions</a>:          Check a Response against the locale.
+<li><a href="#Standard Locales">Standard Locales</a>:             Locale names available on all systems. 
+<li><a href="#Locale Information">Locale Information</a>:           How to access the information for the locale. 
+<li><a href="#Formatting Numbers">Formatting Numbers</a>:           A dedicated function to format numbers. 
+<li><a href="#Yes-or-No Questions">Yes-or-No Questions</a>:          Check a Response against the locale.
 
 <p>Locale Information
 
-</p><li><a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>:    ISO C's <code>localeconv</code>. 
-<li><a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>:       X/Open's <code>nl_langinfo</code>.
+</p><li><a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>:    ISO C's <code>localeconv</code>. 
+<li><a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>:       X/Open's <code>nl_langinfo</code>.
 
 <p>The Lame Way to Locale Data
 
-</p><li><a href="#General%20Numeric">General Numeric</a>:              Parameters for formatting numbers and
+</p><li><a href="#General Numeric">General Numeric</a>:              Parameters for formatting numbers and
                                  currency amounts. 
-<li><a href="#Currency%20Symbol">Currency Symbol</a>:              How to print the symbol that identifies an
+<li><a href="#Currency Symbol">Currency Symbol</a>:              How to print the symbol that identifies an
                                  amount of money (e.g. <code>$</code>). 
-<li><a href="#Sign%20of%20Money%20Amount">Sign of Money Amount</a>:         How to print the (positive or negative) sign
+<li><a href="#Sign of Money Amount">Sign of Money Amount</a>:         How to print the (positive or negative) sign
                                  for a monetary amount, if one exists.
 
 <p>Message Translation
 
-</p><li><a href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>:   The <code>catgets</code> family of functions. 
-<li><a href="#The%20Uniforum%20approach">The Uniforum approach</a>:          The <code>gettext</code> family of functions.
+</p><li><a href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>:   The <code>catgets</code> family of functions. 
+<li><a href="#The Uniforum approach">The Uniforum approach</a>:          The <code>gettext</code> family of functions.
 
 <p>Message catalogs a la X/Open
 
-</p><li><a href="#The%20catgets%20Functions">The catgets Functions</a>:       The <code>catgets</code> function family. 
-<li><a href="#The%20message%20catalog%20files">The message catalog files</a>:   Format of the message catalog files. 
-<li><a href="#The%20gencat%20program">The gencat program</a>:          How to generate message catalogs files which
+</p><li><a href="#The catgets Functions">The catgets Functions</a>:       The <code>catgets</code> function family. 
+<li><a href="#The message catalog files">The message catalog files</a>:   Format of the message catalog files. 
+<li><a href="#The gencat program">The gencat program</a>:          How to generate message catalogs files which
                                 can be used by the functions. 
-<li><a href="#Common%20Usage">Common Usage</a>:                How to use the <code>catgets</code> interface.
+<li><a href="#Common Usage">Common Usage</a>:                How to use the <code>catgets</code> interface.
 
 <p>The Uniforum approach
 
-</p><li><a href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>:   The <code>gettext</code> family of functions. 
-<li><a href="#Helper%20programs%20for%20gettext">Helper programs for gettext</a>:     Programs to handle message catalogs
+</p><li><a href="#Message catalogs with gettext">Message catalogs with gettext</a>:   The <code>gettext</code> family of functions. 
+<li><a href="#Helper programs for gettext">Helper programs for gettext</a>:     Programs to handle message catalogs
                                     for <code>gettext</code>.
 
 <p>Message catalogs with gettext
 
-</p><li><a href="#Translation%20with%20gettext">Translation with gettext</a>:        What has to be done to translate a message. 
-<li><a href="#Locating%20gettext%20catalog">Locating gettext catalog</a>:        How to determine which catalog to be used. 
-<li><a href="#Advanced%20gettext%20functions">Advanced gettext functions</a>:      Additional functions for more complicated
+</p><li><a href="#Translation with gettext">Translation with gettext</a>:        What has to be done to translate a message. 
+<li><a href="#Locating gettext catalog">Locating gettext catalog</a>:        How to determine which catalog to be used. 
+<li><a href="#Advanced gettext functions">Advanced gettext functions</a>:      Additional functions for more complicated
                                     situations. 
-<li><a href="#Charset%20conversion%20in%20gettext">Charset conversion in gettext</a>:   How to specify the output character set
+<li><a href="#Charset conversion in gettext">Charset conversion in gettext</a>:   How to specify the output character set
                                     <code>gettext</code> uses. 
-<li><a href="#GUI%20program%20problems">GUI program problems</a>:            How to use <code>gettext</code> in GUI programs. 
-<li><a href="#Using%20gettextized%20software">Using gettextized software</a>:      The possibilities of the user to influence
+<li><a href="#GUI program problems">GUI program problems</a>:            How to use <code>gettext</code> in GUI programs. 
+<li><a href="#Using gettextized software">Using gettextized software</a>:      The possibilities of the user to influence
                                     the way <code>gettext</code> works.
 
 <p>Searching and Sorting
 
-</p><li><a href="#Comparison%20Functions">Comparison Functions</a>:         Defining how to compare two objects. 
+</p><li><a href="#Comparison Functions">Comparison Functions</a>:         Defining how to compare two objects. 
 				 Since the sort and search facilities
                                  are general, you have to specify the
                                  ordering. 
-<li><a href="#Array%20Search%20Function">Array Search Function</a>:        The <code>bsearch</code> function. 
-<li><a href="#Array%20Sort%20Function">Array Sort Function</a>:          The <code>qsort</code> function. 
-<li><a href="#Search%2fSort%20Example">Search/Sort Example</a>:          An example program. 
-<li><a href="#Hash%20Search%20Function">Hash Search Function</a>:         The <code>hsearch</code> function. 
-<li><a href="#Tree%20Search%20Function">Tree Search Function</a>:         The <code>tsearch</code> function.
+<li><a href="#Array Search Function">Array Search Function</a>:        The <code>bsearch</code> function. 
+<li><a href="#Array Sort Function">Array Sort Function</a>:          The <code>qsort</code> function. 
+<li><a href="#Search%2fSort Example">Search/Sort Example</a>:          An example program. 
+<li><a href="#Hash Search Function">Hash Search Function</a>:         The <code>hsearch</code> function. 
+<li><a href="#Tree Search Function">Tree Search Function</a>:         The <code>tsearch</code> function.
 
 <p>Pattern Matching
 
-</p><li><a href="#Wildcard%20Matching">Wildcard Matching</a>:     Matching a wildcard pattern against a single string. 
+</p><li><a href="#Wildcard Matching">Wildcard Matching</a>:     Matching a wildcard pattern against a single string. 
 <li><a href="#Globbing">Globbing</a>:              Finding the files that match a wildcard pattern. 
-<li><a href="#Regular%20Expressions">Regular Expressions</a>:   Matching regular expressions against strings. 
-<li><a href="#Word%20Expansion">Word Expansion</a>:        Expanding shell variables, nested commands,
+<li><a href="#Regular Expressions">Regular Expressions</a>:   Matching regular expressions against strings. 
+<li><a href="#Word Expansion">Word Expansion</a>:        Expanding shell variables, nested commands,
 			    arithmetic, and wildcards. 
 			    This is what the shell does with shell commands.
 
 <p>Globbing
 
-</p><li><a href="#Calling%20Glob">Calling Glob</a>:              Basic use of <code>glob</code>. 
-<li><a href="#Flags%20for%20Globbing">Flags for Globbing</a>:        Flags that enable various options in <code>glob</code>. 
-<li><a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>:   GNU specific extensions to <code>glob</code>.
+</p><li><a href="#Calling Glob">Calling Glob</a>:              Basic use of <code>glob</code>. 
+<li><a href="#Flags for Globbing">Flags for Globbing</a>:        Flags that enable various options in <code>glob</code>. 
+<li><a href="#More Flags for Globbing">More Flags for Globbing</a>:   GNU specific extensions to <code>glob</code>.
 
 <p>Regular Expressions
 
-</p><li><a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>:     Using <code>regcomp</code> to prepare to match. 
-<li><a href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>:      Syntax variations for <code>regcomp</code>. 
-<li><a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>:       Using <code>regexec</code> to match the compiled
+</p><li><a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>:     Using <code>regcomp</code> to prepare to match. 
+<li><a href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>:      Syntax variations for <code>regcomp</code>. 
+<li><a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>:       Using <code>regexec</code> to match the compiled
 				   pattern that you get from <code>regcomp</code>. 
-<li><a href="#Regexp%20Subexpressions">Regexp Subexpressions</a>:        Finding which parts of the string were matched. 
-<li><a href="#Subexpression%20Complications">Subexpression Complications</a>:  Find points of which parts were matched. 
-<li><a href="#Regexp%20Cleanup">Regexp Cleanup</a>: 		Freeing storage; reporting errors.
+<li><a href="#Regexp Subexpressions">Regexp Subexpressions</a>:        Finding which parts of the string were matched. 
+<li><a href="#Subexpression Complications">Subexpression Complications</a>:  Find points of which parts were matched. 
+<li><a href="#Regexp Cleanup">Regexp Cleanup</a>: 		Freeing storage; reporting errors.
 
 <p>Word Expansion
 
-</p><li><a href="#Expansion%20Stages">Expansion Stages</a>:             What word expansion does to a string. 
-<li><a href="#Calling%20Wordexp">Calling Wordexp</a>:              How to call <code>wordexp</code>. 
-<li><a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>:            Options you can enable in <code>wordexp</code>. 
-<li><a href="#Wordexp%20Example">Wordexp Example</a>:              A sample program that does word expansion. 
-<li><a href="#Tilde%20Expansion">Tilde Expansion</a>:              Details of how tilde expansion works. 
-<li><a href="#Variable%20Substitution">Variable Substitution</a>:        Different types of variable substitution.
+</p><li><a href="#Expansion Stages">Expansion Stages</a>:             What word expansion does to a string. 
+<li><a href="#Calling Wordexp">Calling Wordexp</a>:              How to call <code>wordexp</code>. 
+<li><a href="#Flags for Wordexp">Flags for Wordexp</a>:            Options you can enable in <code>wordexp</code>. 
+<li><a href="#Wordexp Example">Wordexp Example</a>:              A sample program that does word expansion. 
+<li><a href="#Tilde Expansion">Tilde Expansion</a>:              Details of how tilde expansion works. 
+<li><a href="#Variable Substitution">Variable Substitution</a>:        Different types of variable substitution.
 
 <p>I/O Overview
 
-</p><li><a href="#I%2fO%20Concepts">I/O Concepts</a>:        Some basic information and terminology. 
-<li><a href="#File%20Names">File Names</a>:          How to refer to a file.
+</p><li><a href="#I%2fO Concepts">I/O Concepts</a>:        Some basic information and terminology. 
+<li><a href="#File Names">File Names</a>:          How to refer to a file.
 
 <p>I/O Concepts
 
-</p><li><a href="#Streams%20and%20File%20Descriptors">Streams and File Descriptors</a>:     The GNU Library provides two ways
+</p><li><a href="#Streams and File Descriptors">Streams and File Descriptors</a>:     The GNU Library provides two ways
 			             to access the contents of files. 
-<li><a href="#File%20Position">File Position</a>:                    The number of bytes from the
+<li><a href="#File Position">File Position</a>:                    The number of bytes from the
                                      beginning of the file.
 
 <p>File Names
 
 </p><li><a href="#Directories">Directories</a>:                  Directories contain entries for files. 
-<li><a href="#File%20Name%20Resolution">File Name Resolution</a>:         A file name specifies how to look up a file. 
-<li><a href="#File%20Name%20Errors">File Name Errors</a>:             Error conditions relating to file names. 
-<li><a href="#File%20Name%20Portability">File Name Portability</a>:        File name portability and syntax issues.
+<li><a href="#File Name Resolution">File Name Resolution</a>:         A file name specifies how to look up a file. 
+<li><a href="#File Name Errors">File Name Errors</a>:             Error conditions relating to file names. 
+<li><a href="#File Name Portability">File Name Portability</a>:        File name portability and syntax issues.
 
 <p>I/O on Streams
 
 </p><li><a href="#Streams">Streams</a>:                      About the data type representing a stream. 
-<li><a href="#Standard%20Streams">Standard Streams</a>:             Streams to the standard input and output
+<li><a href="#Standard Streams">Standard Streams</a>:             Streams to the standard input and output
                                  devices are created for you. 
-<li><a href="#Opening%20Streams">Opening Streams</a>:              How to create a stream to talk to a file. 
-<li><a href="#Closing%20Streams">Closing Streams</a>:              Close a stream when you are finished with it. 
-<li><a href="#Streams%20and%20Threads">Streams and Threads</a>:          Issues with streams in threaded programs. 
-<li><a href="#Streams%20and%20I18N">Streams and I18N</a>:             Streams in internationalized applications. 
-<li><a href="#Simple%20Output">Simple Output</a>:                Unformatted output by characters and lines. 
-<li><a href="#Character%20Input">Character Input</a>:              Unformatted input by characters and words. 
-<li><a href="#Line%20Input">Line Input</a>:                   Reading a line or a record from a stream. 
+<li><a href="#Opening Streams">Opening Streams</a>:              How to create a stream to talk to a file. 
+<li><a href="#Closing Streams">Closing Streams</a>:              Close a stream when you are finished with it. 
+<li><a href="#Streams and Threads">Streams and Threads</a>:          Issues with streams in threaded programs. 
+<li><a href="#Streams and I18N">Streams and I18N</a>:             Streams in internationalized applications. 
+<li><a href="#Simple Output">Simple Output</a>:                Unformatted output by characters and lines. 
+<li><a href="#Character Input">Character Input</a>:              Unformatted input by characters and words. 
+<li><a href="#Line Input">Line Input</a>:                   Reading a line or a record from a stream. 
 <li><a href="#Unreading">Unreading</a>:                    Peeking ahead/pushing back input just read. 
-<li><a href="#Block%20Input%2fOutput">Block Input/Output</a>:           Input and output operations on blocks of data. 
-<li><a href="#Formatted%20Output">Formatted Output</a>:             <code>printf</code> and related functions. 
-<li><a href="#Customizing%20Printf">Customizing Printf</a>:           You can define new conversion specifiers for
+<li><a href="#Block Input%2fOutput">Block Input/Output</a>:           Input and output operations on blocks of data. 
+<li><a href="#Formatted Output">Formatted Output</a>:             <code>printf</code> and related functions. 
+<li><a href="#Customizing Printf">Customizing Printf</a>:           You can define new conversion specifiers for
                                  <code>printf</code> and friends. 
-<li><a href="#Formatted%20Input">Formatted Input</a>:              <code>scanf</code> and related functions. 
-<li><a href="#EOF%20and%20Errors">EOF and Errors</a>:               How you can tell if an I/O error happens. 
-<li><a href="#Error%20Recovery">Error Recovery</a>: 		What you can do about errors. 
-<li><a href="#Binary%20Streams">Binary Streams</a>:               Some systems distinguish between text files
+<li><a href="#Formatted Input">Formatted Input</a>:              <code>scanf</code> and related functions. 
+<li><a href="#EOF and Errors">EOF and Errors</a>:               How you can tell if an I/O error happens. 
+<li><a href="#Error Recovery">Error Recovery</a>: 		What you can do about errors. 
+<li><a href="#Binary Streams">Binary Streams</a>:               Some systems distinguish between text files
                                  and binary files. 
-<li><a href="#File%20Positioning">File Positioning</a>:             About random-access streams. 
-<li><a href="#Portable%20Positioning">Portable Positioning</a>:         Random access on peculiar ISO C systems. 
-<li><a href="#Stream%20Buffering">Stream Buffering</a>:             How to control buffering of streams. 
-<li><a href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>:       Streams that do not necessarily correspond
+<li><a href="#File Positioning">File Positioning</a>:             About random-access streams. 
+<li><a href="#Portable Positioning">Portable Positioning</a>:         Random access on peculiar ISO C systems. 
+<li><a href="#Stream Buffering">Stream Buffering</a>:             How to control buffering of streams. 
+<li><a href="#Other Kinds of Streams">Other Kinds of Streams</a>:       Streams that do not necessarily correspond
                                  to an open file. 
-<li><a href="#Formatted%20Messages">Formatted Messages</a>:           Print strictly formatted messages.
+<li><a href="#Formatted Messages">Formatted Messages</a>:           Print strictly formatted messages.
 
 <p>Unreading
 
-</p><li><a href="#Unreading%20Idea">Unreading Idea</a>:               An explanation of unreading with pictures. 
-<li><a href="#How%20Unread">How Unread</a>:                   How to call <code>ungetc</code> to do unreading.
+</p><li><a href="#Unreading Idea">Unreading Idea</a>:               An explanation of unreading with pictures. 
+<li><a href="#How Unread">How Unread</a>:                   How to call <code>ungetc</code> to do unreading.
 
 <p>Formatted Output
 
-</p><li><a href="#Formatted%20Output%20Basics">Formatted Output Basics</a>:      Some examples to get you started. 
-<li><a href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>:     General syntax of conversion
+</p><li><a href="#Formatted Output Basics">Formatted Output Basics</a>:      Some examples to get you started. 
+<li><a href="#Output Conversion Syntax">Output Conversion Syntax</a>:     General syntax of conversion
                                  specifications. 
-<li><a href="#Table%20of%20Output%20Conversions">Table of Output Conversions</a>:  Summary of output conversions and
+<li><a href="#Table of Output Conversions">Table of Output Conversions</a>:  Summary of output conversions and
                                  what they do. 
-<li><a href="#Integer%20Conversions">Integer Conversions</a>:          Details about formatting of integers. 
-<li><a href="#Floating-Point%20Conversions">Floating-Point Conversions</a>:   Details about formatting of
+<li><a href="#Integer Conversions">Integer Conversions</a>:          Details about formatting of integers. 
+<li><a href="#Floating-Point Conversions">Floating-Point Conversions</a>:   Details about formatting of
                                  floating-point numbers. 
-<li><a href="#Other%20Output%20Conversions">Other Output Conversions</a>:     Details about formatting of strings,
+<li><a href="#Other Output Conversions">Other Output Conversions</a>:     Details about formatting of strings,
                                  characters, pointers, and the like. 
-<li><a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>:   Descriptions of the actual functions. 
-<li><a href="#Dynamic%20Output">Dynamic Output</a>: 		Functions that allocate memory for the output. 
-<li><a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>:    <code>vprintf</code> and friends. 
-<li><a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>:    What kinds of args does a given template
+<li><a href="#Formatted Output Functions">Formatted Output Functions</a>:   Descriptions of the actual functions. 
+<li><a href="#Dynamic Output">Dynamic Output</a>: 		Functions that allocate memory for the output. 
+<li><a href="#Variable Arguments Output">Variable Arguments Output</a>:    <code>vprintf</code> and friends. 
+<li><a href="#Parsing a Template String">Parsing a Template String</a>:    What kinds of args does a given template
                                  call for? 
-<li><a href="#Example%20of%20Parsing">Example of Parsing</a>:           Sample program using <code>parse_printf_format</code>.
+<li><a href="#Example of Parsing">Example of Parsing</a>:           Sample program using <code>parse_printf_format</code>.
 
 <p>Customizing Printf
 
-</p><li><a href="#Registering%20New%20Conversions">Registering New Conversions</a>:          Using <code>register_printf_function</code>
+</p><li><a href="#Registering New Conversions">Registering New Conversions</a>:          Using <code>register_printf_function</code>
                                          to register a new output conversion. 
-<li><a href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>:         The handler must be able to get
+<li><a href="#Conversion Specifier Options">Conversion Specifier Options</a>:         The handler must be able to get
                                          the options specified in the
                                          template when it is called. 
-<li><a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>:          Defining the handler and arginfo
+<li><a href="#Defining the Output Handler">Defining the Output Handler</a>:          Defining the handler and arginfo
                                          functions that are passed as arguments
                                          to <code>register_printf_function</code>. 
-<li><a href="#Printf%20Extension%20Example">Printf Extension Example</a>:             How to define a <code>printf</code>
+<li><a href="#Printf Extension Example">Printf Extension Example</a>:             How to define a <code>printf</code>
                                          handler function. 
-<li><a href="#Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>:           Predefined <code>printf</code> handlers.
+<li><a href="#Predefined Printf Handlers">Predefined Printf Handlers</a>:           Predefined <code>printf</code> handlers.
 
 <p>Formatted Input
 
-</p><li><a href="#Formatted%20Input%20Basics">Formatted Input Basics</a>:       Some basics to get you started. 
-<li><a href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>:      Syntax of conversion specifications. 
-<li><a href="#Table%20of%20Input%20Conversions">Table of Input Conversions</a>:   Summary of input conversions and what they do. 
-<li><a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>:    Details of conversions for reading numbers. 
-<li><a href="#String%20Input%20Conversions">String Input Conversions</a>:     Details of conversions for reading strings. 
-<li><a href="#Dynamic%20String%20Input">Dynamic String Input</a>: 	String conversions that <code>malloc</code> the buffer. 
-<li><a href="#Other%20Input%20Conversions">Other Input Conversions</a>:      Details of miscellaneous other conversions. 
-<li><a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>:    Descriptions of the actual functions. 
-<li><a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>:     <code>vscanf</code> and friends.
+</p><li><a href="#Formatted Input Basics">Formatted Input Basics</a>:       Some basics to get you started. 
+<li><a href="#Input Conversion Syntax">Input Conversion Syntax</a>:      Syntax of conversion specifications. 
+<li><a href="#Table of Input Conversions">Table of Input Conversions</a>:   Summary of input conversions and what they do. 
+<li><a href="#Numeric Input Conversions">Numeric Input Conversions</a>:    Details of conversions for reading numbers. 
+<li><a href="#String Input Conversions">String Input Conversions</a>:     Details of conversions for reading strings. 
+<li><a href="#Dynamic String Input">Dynamic String Input</a>: 	String conversions that <code>malloc</code> the buffer. 
+<li><a href="#Other Input Conversions">Other Input Conversions</a>:      Details of miscellaneous other conversions. 
+<li><a href="#Formatted Input Functions">Formatted Input Functions</a>:    Descriptions of the actual functions. 
+<li><a href="#Variable Arguments Input">Variable Arguments Input</a>:     <code>vscanf</code> and friends.
 
 <p>Stream Buffering
 
-</p><li><a href="#Buffering%20Concepts">Buffering Concepts</a>:           Terminology is defined here. 
-<li><a href="#Flushing%20Buffers">Flushing Buffers</a>:             How to ensure that output buffers are flushed. 
-<li><a href="#Controlling%20Buffering">Controlling Buffering</a>:        How to specify what kind of buffering to use.
+</p><li><a href="#Buffering Concepts">Buffering Concepts</a>:           Terminology is defined here. 
+<li><a href="#Flushing Buffers">Flushing Buffers</a>:             How to ensure that output buffers are flushed. 
+<li><a href="#Controlling Buffering">Controlling Buffering</a>:        How to specify what kind of buffering to use.
 
 <p>Other Kinds of Streams
 
-</p><li><a href="#String%20Streams">String Streams</a>:               Streams that get data from or put data in
+</p><li><a href="#String Streams">String Streams</a>:               Streams that get data from or put data in
                                  a string or memory buffer. 
-<li><a href="#Obstack%20Streams">Obstack Streams</a>: 		Streams that store data in an obstack. 
-<li><a href="#Custom%20Streams">Custom Streams</a>:               Defining your own streams with an arbitrary
+<li><a href="#Obstack Streams">Obstack Streams</a>: 		Streams that store data in an obstack. 
+<li><a href="#Custom Streams">Custom Streams</a>:               Defining your own streams with an arbitrary
                                  input data source and/or output data sink.
 
 <p>Custom Streams
 
-</p><li><a href="#Streams%20and%20Cookies">Streams and Cookies</a>:          The <dfn>cookie</dfn> records where to fetch or
+</p><li><a href="#Streams and Cookies">Streams and Cookies</a>:          The <dfn>cookie</dfn> records where to fetch or
                                  store data that is read or written. 
-<li><a href="#Hook%20Functions">Hook Functions</a>:               How you should define the four <dfn>hook
+<li><a href="#Hook Functions">Hook Functions</a>:               How you should define the four <dfn>hook
                                  functions</dfn> that a custom stream needs.
 
 <p>Formatted Messages
 
-</p><li><a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>:    The <code>fmtmsg</code> function. 
-<li><a href="#Adding%20Severity%20Classes">Adding Severity Classes</a>:        Add more severity classes. 
+</p><li><a href="#Printing Formatted Messages">Printing Formatted Messages</a>:    The <code>fmtmsg</code> function. 
+<li><a href="#Adding Severity Classes">Adding Severity Classes</a>:        Add more severity classes. 
 <li><a href="#Example">Example</a>:                        How to use <code>fmtmsg</code> and <code>addseverity</code>.
 
 <p>Low-Level I/O
 
-</p><li><a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>:            How to open and close file
+</p><li><a href="#Opening and Closing Files">Opening and Closing Files</a>:            How to open and close file
                                          descriptors. 
-<li><a href="#I%2fO%20Primitives">I/O Primitives</a>:                       Reading and writing data. 
-<li><a href="#File%20Position%20Primitive">File Position Primitive</a>:              Setting a descriptor's file
+<li><a href="#I%2fO Primitives">I/O Primitives</a>:                       Reading and writing data. 
+<li><a href="#File Position Primitive">File Position Primitive</a>:              Setting a descriptor's file
                                          position. 
-<li><a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>:              Converting descriptor to stream
+<li><a href="#Descriptors and Streams">Descriptors and Streams</a>:              Converting descriptor to stream
                                          or vice-versa. 
-<li><a href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>:        Precautions needed if you use both
+<li><a href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>:        Precautions needed if you use both
                                          descriptors and streams. 
 <li><a href="#Scatter-Gather">Scatter-Gather</a>:                       Fast I/O to discontinuous buffers. 
-<li><a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>:                    Using files like memory. 
-<li><a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>:                      How to check for input or output
+<li><a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>:                    Using files like memory. 
+<li><a href="#Waiting for I%2fO">Waiting for I/O</a>:                      How to check for input or output
 					 on multiple file descriptors. 
-<li><a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>:                    Making sure all I/O actions completed. 
-<li><a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>:                     Perform I/O in parallel. 
-<li><a href="#Control%20Operations">Control Operations</a>:                   Various other operations on file
+<li><a href="#Synchronizing I%2fO">Synchronizing I/O</a>:                    Making sure all I/O actions completed. 
+<li><a href="#Asynchronous I%2fO">Asynchronous I/O</a>:                     Perform I/O in parallel. 
+<li><a href="#Control Operations">Control Operations</a>:                   Various other operations on file
 					 descriptors. 
-<li><a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>:              Fcntl commands for duplicating
+<li><a href="#Duplicating Descriptors">Duplicating Descriptors</a>:              Fcntl commands for duplicating
                                          file descriptors. 
-<li><a href="#Descriptor%20Flags">Descriptor Flags</a>:                     Fcntl commands for manipulating
+<li><a href="#Descriptor Flags">Descriptor Flags</a>:                     Fcntl commands for manipulating
                                          flags associated with file
                                          descriptors. 
-<li><a href="#File%20Status%20Flags">File Status Flags</a>:                    Fcntl commands for manipulating
+<li><a href="#File Status Flags">File Status Flags</a>:                    Fcntl commands for manipulating
                                          flags associated with open files. 
-<li><a href="#File%20Locks">File Locks</a>:                           Fcntl commands for implementing
+<li><a href="#File Locks">File Locks</a>:                           Fcntl commands for implementing
                                          file locking. 
-<li><a href="#Interrupt%20Input">Interrupt Input</a>:                      Getting an asynchronous signal when
+<li><a href="#Interrupt Input">Interrupt Input</a>:                      Getting an asynchronous signal when
                                          input arrives. 
 <li><a href="#IOCTLs">IOCTLs</a>:                               Generic I/O Control operations.
 
 <p>Stream/Descriptor Precautions
 
-</p><li><a href="#Linked%20Channels">Linked Channels</a>: 	   Dealing with channels sharing a file position. 
-<li><a href="#Independent%20Channels">Independent Channels</a>:    Dealing with separately opened, unlinked channels. 
-<li><a href="#Cleaning%20Streams">Cleaning Streams</a>: 	   Cleaning a stream makes it safe to use
+</p><li><a href="#Linked Channels">Linked Channels</a>: 	   Dealing with channels sharing a file position. 
+<li><a href="#Independent Channels">Independent Channels</a>:    Dealing with separately opened, unlinked channels. 
+<li><a href="#Cleaning Streams">Cleaning Streams</a>: 	   Cleaning a stream makes it safe to use
                             another channel.
 
 <p>Asynchronous I/O
 
-</p><li><a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>:     Asynchronous Read and Write Operations. 
-<li><a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>:      Getting the Status of AIO Operations. 
-<li><a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>:  Getting into a consistent state. 
-<li><a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>:         Cancellation of AIO Operations. 
-<li><a href="#Configuration%20of%20AIO">Configuration of AIO</a>:          How to optimize the AIO implementation.
+</p><li><a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>:     Asynchronous Read and Write Operations. 
+<li><a href="#Status of AIO Operations">Status of AIO Operations</a>:      Getting the Status of AIO Operations. 
+<li><a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>:  Getting into a consistent state. 
+<li><a href="#Cancel AIO Operations">Cancel AIO Operations</a>:         Cancellation of AIO Operations. 
+<li><a href="#Configuration of AIO">Configuration of AIO</a>:          How to optimize the AIO implementation.
 
 <p>File Status Flags
 
-</p><li><a href="#Access%20Modes">Access Modes</a>:                 Whether the descriptor can read or write. 
-<li><a href="#Open-time%20Flags">Open-time Flags</a>:              Details of <code>open</code>. 
-<li><a href="#Operating%20Modes">Operating Modes</a>:              Special modes to control I/O operations. 
-<li><a href="#Getting%20File%20Status%20Flags">Getting File Status Flags</a>:    Fetching and changing these flags.
+</p><li><a href="#Access Modes">Access Modes</a>:                 Whether the descriptor can read or write. 
+<li><a href="#Open-time Flags">Open-time Flags</a>:              Details of <code>open</code>. 
+<li><a href="#Operating Modes">Operating Modes</a>:              Special modes to control I/O operations. 
+<li><a href="#Getting File Status Flags">Getting File Status Flags</a>:    Fetching and changing these flags.
 
 <p>File System Interface
 
-</p><li><a href="#Working%20Directory">Working Directory</a>:            This is used to resolve relative
+</p><li><a href="#Working Directory">Working Directory</a>:            This is used to resolve relative
 				 file names. 
-<li><a href="#Accessing%20Directories">Accessing Directories</a>:        Finding out what files a directory
+<li><a href="#Accessing Directories">Accessing Directories</a>:        Finding out what files a directory
 				 contains. 
-<li><a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>:  Apply actions to all files or a selectable
+<li><a href="#Working with Directory Trees">Working with Directory Trees</a>:  Apply actions to all files or a selectable
                                  subset of a directory hierarchy. 
-<li><a href="#Hard%20Links">Hard Links</a>:                   Adding alternate names to a file. 
-<li><a href="#Symbolic%20Links">Symbolic Links</a>:               A file that ``points to'' a file name. 
-<li><a href="#Deleting%20Files">Deleting Files</a>:               How to delete a file, and what that means. 
-<li><a href="#Renaming%20Files">Renaming Files</a>:               Changing a file's name. 
-<li><a href="#Creating%20Directories">Creating Directories</a>:         A system call just for creating a directory. 
-<li><a href="#File%20Attributes">File Attributes</a>:              Attributes of individual files. 
-<li><a href="#Making%20Special%20Files">Making Special Files</a>:         How to create special files. 
-<li><a href="#Temporary%20Files">Temporary Files</a>:              Naming and creating temporary files.
+<li><a href="#Hard Links">Hard Links</a>:                   Adding alternate names to a file. 
+<li><a href="#Symbolic Links">Symbolic Links</a>:               A file that "points to" a file name. 
+<li><a href="#Deleting Files">Deleting Files</a>:               How to delete a file, and what that means. 
+<li><a href="#Renaming Files">Renaming Files</a>:               Changing a file's name. 
+<li><a href="#Creating Directories">Creating Directories</a>:         A system call just for creating a directory. 
+<li><a href="#File Attributes">File Attributes</a>:              Attributes of individual files. 
+<li><a href="#Making Special Files">Making Special Files</a>:         How to create special files. 
+<li><a href="#Temporary Files">Temporary Files</a>:              Naming and creating temporary files.
 
 <p>Accessing Directories
 
-</p><li><a href="#Directory%20Entries">Directory Entries</a>:            Format of one directory entry. 
-<li><a href="#Opening%20a%20Directory">Opening a Directory</a>:          How to open a directory stream. 
-<li><a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>:    How to read directory entries from the stream. 
-<li><a href="#Simple%20Directory%20Lister">Simple Directory Lister</a>:      A very simple directory listing program. 
-<li><a href="#Random%20Access%20Directory">Random Access Directory</a>:      Rereading part of the directory
+</p><li><a href="#Directory Entries">Directory Entries</a>:            Format of one directory entry. 
+<li><a href="#Opening a Directory">Opening a Directory</a>:          How to open a directory stream. 
+<li><a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>:    How to read directory entries from the stream. 
+<li><a href="#Simple Directory Lister">Simple Directory Lister</a>:      A very simple directory listing program. 
+<li><a href="#Random Access Directory">Random Access Directory</a>:      Rereading part of the directory
                                  already read with the same stream. 
-<li><a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>:   Get entries for user selected subset of
+<li><a href="#Scanning Directory Content">Scanning Directory Content</a>:   Get entries for user selected subset of
                                  contents in given directory. 
-<li><a href="#Simple%20Directory%20Lister%20Mark%20II">Simple Directory Lister Mark II</a>:   Revised version of the program.
+<li><a href="#Simple Directory Lister Mark II">Simple Directory Lister Mark II</a>:   Revised version of the program.
 
 <p>File Attributes
 
-</p><li><a href="#Attribute%20Meanings">Attribute Meanings</a>:           The names of the file attributes,
+</p><li><a href="#Attribute Meanings">Attribute Meanings</a>:           The names of the file attributes,
                                  and what their values mean. 
-<li><a href="#Reading%20Attributes">Reading Attributes</a>:           How to read the attributes of a file. 
-<li><a href="#Testing%20File%20Type">Testing File Type</a>:            Distinguishing ordinary files,
+<li><a href="#Reading Attributes">Reading Attributes</a>:           How to read the attributes of a file. 
+<li><a href="#Testing File Type">Testing File Type</a>:            Distinguishing ordinary files,
                                  directories, links... 
-<li><a href="#File%20Owner">File Owner</a>:                   How ownership for new files is determined,
+<li><a href="#File Owner">File Owner</a>:                   How ownership for new files is determined,
 			         and how to change it. 
-<li><a href="#Permission%20Bits">Permission Bits</a>:              How information about a file's access
+<li><a href="#Permission Bits">Permission Bits</a>:              How information about a file's access
                                  mode is stored. 
-<li><a href="#Access%20Permission">Access Permission</a>:            How the system decides who can access a file. 
-<li><a href="#Setting%20Permissions">Setting Permissions</a>:          How permissions for new files are assigned,
+<li><a href="#Access Permission">Access Permission</a>:            How the system decides who can access a file. 
+<li><a href="#Setting Permissions">Setting Permissions</a>:          How permissions for new files are assigned,
 			         and how to change them. 
-<li><a href="#Testing%20File%20Access">Testing File Access</a>:          How to find out if your process can
+<li><a href="#Testing File Access">Testing File Access</a>:          How to find out if your process can
                                  access a file. 
-<li><a href="#File%20Times">File Times</a>:                   About the time attributes of a file. 
-<li><a href="#File%20Size">File Size</a>: 			Manually changing the size of a file.
+<li><a href="#File Times">File Times</a>:                   About the time attributes of a file. 
+<li><a href="#File Size">File Size</a>: 			Manually changing the size of a file.
 
 <p>Pipes and FIFOs
 
-</p><li><a href="#Creating%20a%20Pipe">Creating a Pipe</a>:              Making a pipe with the <code>pipe</code> function. 
-<li><a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>:         Using a pipe to communicate with a
+</p><li><a href="#Creating a Pipe">Creating a Pipe</a>:              Making a pipe with the <code>pipe</code> function. 
+<li><a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>:         Using a pipe to communicate with a
 				 child process. 
-<li><a href="#FIFO%20Special%20Files">FIFO Special Files</a>:           Making a FIFO special file. 
-<li><a href="#Pipe%20Atomicity">Pipe Atomicity</a>: 		When pipe (or FIFO) I/O is atomic.
+<li><a href="#FIFO Special Files">FIFO Special Files</a>:           Making a FIFO special file. 
+<li><a href="#Pipe Atomicity">Pipe Atomicity</a>: 		When pipe (or FIFO) I/O is atomic.
 
 <p>Sockets
 
-</p><li><a href="#Socket%20Concepts">Socket Concepts</a>: 	Basic concepts you need to know about. 
-<li><a href="#Communication%20Styles">Communication Styles</a>: Stream communication, datagrams and other styles. 
-<li><a href="#Socket%20Addresses">Socket Addresses</a>: 	How socket names (``addresses'') work. 
-<li><a href="#Interface%20Naming">Interface Naming</a>: 	Identifying specific network interfaces. 
-<li><a href="#Local%20Namespace">Local Namespace</a>: 	Details about the local namespace. 
-<li><a href="#Internet%20Namespace">Internet Namespace</a>: 	Details about the Internet namespace. 
-<li><a href="#Misc%20Namespaces">Misc Namespaces</a>: 	Other namespaces not documented fully here. 
-<li><a href="#Open%2fClose%20Sockets">Open/Close Sockets</a>:   Creating sockets and destroying them. 
+</p><li><a href="#Socket Concepts">Socket Concepts</a>: 	Basic concepts you need to know about. 
+<li><a href="#Communication Styles">Communication Styles</a>: Stream communication, datagrams and other styles. 
+<li><a href="#Socket Addresses">Socket Addresses</a>: 	How socket names ("addresses") work. 
+<li><a href="#Interface Naming">Interface Naming</a>: 	Identifying specific network interfaces. 
+<li><a href="#Local Namespace">Local Namespace</a>: 	Details about the local namespace. 
+<li><a href="#Internet Namespace">Internet Namespace</a>: 	Details about the Internet namespace. 
+<li><a href="#Misc Namespaces">Misc Namespaces</a>: 	Other namespaces not documented fully here. 
+<li><a href="#Open%2fClose Sockets">Open/Close Sockets</a>:   Creating sockets and destroying them. 
 <li><a href="#Connections">Connections</a>: 		Operations on sockets with connection state. 
 <li><a href="#Datagrams">Datagrams</a>: 		Operations on datagram sockets. 
 <li><a href="#Inetd">Inetd</a>: 		Inetd is a daemon that starts servers on request. 
 			   The most convenient way to write a server
 			   is to make it work with Inetd. 
-<li><a href="#Socket%20Options">Socket Options</a>: 	Miscellaneous low-level socket options. 
-<li><a href="#Networks%20Database">Networks Database</a>:    Accessing the database of network names.
+<li><a href="#Socket Options">Socket Options</a>: 	Miscellaneous low-level socket options. 
+<li><a href="#Networks Database">Networks Database</a>:    Accessing the database of network names.
 
 <p>Socket Addresses
 
-</p><li><a href="#Address%20Formats">Address Formats</a>: 		About <code>struct sockaddr</code>. 
-<li><a href="#Setting%20Address">Setting Address</a>: 		Binding an address to a socket. 
-<li><a href="#Reading%20Address">Reading Address</a>: 		Reading the address of a socket.
+</p><li><a href="#Address Formats">Address Formats</a>: 		About <code>struct sockaddr</code>. 
+<li><a href="#Setting Address">Setting Address</a>: 		Binding an address to a socket. 
+<li><a href="#Reading Address">Reading Address</a>: 		Reading the address of a socket.
 
 <p>Local Namespace
 
-</p><li><a href="#Local%20Namespace%20Concepts">Concepts</a>:  What you need to understand. 
-<li><a href="#Local%20Namespace%20Details">Details</a>:    Address format, symbolic names, etc. 
-<li><a href="#Local%20Socket%20Example">Example</a>:       Example of creating a socket.
+</p><li><a href="#Local Namespace Concepts">Concepts</a>:  What you need to understand. 
+<li><a href="#Local Namespace Details">Details</a>:    Address format, symbolic names, etc. 
+<li><a href="#Local Socket Example">Example</a>:       Example of creating a socket.
 
 <p>Internet Namespace
 
-</p><li><a href="#Internet%20Address%20Formats">Internet Address Formats</a>:     How socket addresses are specified in the
+</p><li><a href="#Internet Address Formats">Internet Address Formats</a>:     How socket addresses are specified in the
                                  Internet namespace. 
-<li><a href="#Host%20Addresses">Host Addresses</a>: 	        All about host addresses of Internet host. 
-<li><a href="#Protocols%20Database">Protocols Database</a>: 		Referring to protocols by name. 
+<li><a href="#Host Addresses">Host Addresses</a>: 	        All about host addresses of Internet host. 
+<li><a href="#Protocols Database">Protocols Database</a>: 		Referring to protocols by name. 
 <li><a href="#Ports">Ports</a>: 			Internet port numbers. 
-<li><a href="#Services%20Database">Services Database</a>:            Ports may have symbolic names. 
-<li><a href="#Byte%20Order">Byte Order</a>: 		        Different hosts may use different byte
+<li><a href="#Services Database">Services Database</a>:            Ports may have symbolic names. 
+<li><a href="#Byte Order">Byte Order</a>: 		        Different hosts may use different byte
                                  ordering conventions; you need to
                                  canonicalize host address and port number. 
-<li><a href="#Inet%20Example">Inet Example</a>: 	        Putting it all together.
+<li><a href="#Inet Example">Inet Example</a>: 	        Putting it all together.
 
 <p>Host Addresses
 
-</p><li><a href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>: 	What a host number consists of. 
-<li><a href="#Host%20Address%20Data%20Type">Data type</a>: 	Data type for a host number. 
-<li><a href="#Host%20Address%20Functions">Functions</a>: 	Functions to operate on them. 
-<li><a href="#Host%20Names">Names</a>: 		Translating host names to host numbers.
+</p><li><a href="#Abstract Host Addresses">Abstract Host Addresses</a>: 	What a host number consists of. 
+<li><a href="#Host Address Data Type">Data type</a>: 	Data type for a host number. 
+<li><a href="#Host Address Functions">Functions</a>: 	Functions to operate on them. 
+<li><a href="#Host Names">Names</a>: 		Translating host names to host numbers.
 
 <p>Open/Close Sockets
 
-</p><li><a href="#Creating%20a%20Socket">Creating a Socket</a>:            How to open a socket. 
-<li><a href="#Closing%20a%20Socket">Closing a Socket</a>:             How to close a socket. 
-<li><a href="#Socket%20Pairs">Socket Pairs</a>:                 These are created like pipes.
+</p><li><a href="#Creating a Socket">Creating a Socket</a>:            How to open a socket. 
+<li><a href="#Closing a Socket">Closing a Socket</a>:             How to close a socket. 
+<li><a href="#Socket Pairs">Socket Pairs</a>:                 These are created like pipes.
 
 <p>Connections
 
 </p><li><a href="#Connecting">Connecting</a>:     	     What the client program must do. 
 <li><a href="#Listening">Listening</a>: 		     How a server program waits for requests. 
-<li><a href="#Accepting%20Connections">Accepting Connections</a>:     What the server does when it gets a request. 
-<li><a href="#Who%20is%20Connected">Who is Connected</a>: 	     Getting the address of the
+<li><a href="#Accepting Connections">Accepting Connections</a>:     What the server does when it gets a request. 
+<li><a href="#Who is Connected">Who is Connected</a>: 	     Getting the address of the
 				other side of a connection. 
-<li><a href="#Transferring%20Data">Transferring Data</a>:         How to send and receive data. 
-<li><a href="#Byte%20Stream%20Example">Byte Stream Example</a>: 	     An example program: a client for communicating
+<li><a href="#Transferring Data">Transferring Data</a>:         How to send and receive data. 
+<li><a href="#Byte Stream Example">Byte Stream Example</a>: 	     An example program: a client for communicating
 			      over a byte stream socket in the Internet namespace. 
-<li><a href="#Server%20Example">Server Example</a>: 	     A corresponding server program. 
-<li><a href="#Out-of-Band%20Data">Out-of-Band Data</a>:          This is an advanced feature.
+<li><a href="#Server Example">Server Example</a>: 	     A corresponding server program. 
+<li><a href="#Out-of-Band Data">Out-of-Band Data</a>:          This is an advanced feature.
 
 <p>Transferring Data
 
-</p><li><a href="#Sending%20Data">Sending Data</a>: 		Sending data with <code>send</code>. 
-<li><a href="#Receiving%20Data">Receiving Data</a>: 		Reading data with <code>recv</code>. 
-<li><a href="#Socket%20Data%20Options">Socket Data Options</a>: 		Using <code>send</code> and <code>recv</code>.
+</p><li><a href="#Sending Data">Sending Data</a>: 		Sending data with <code>send</code>. 
+<li><a href="#Receiving Data">Receiving Data</a>: 		Reading data with <code>recv</code>. 
+<li><a href="#Socket Data Options">Socket Data Options</a>: 		Using <code>send</code> and <code>recv</code>.
 
 <p>Datagrams
 
-</p><li><a href="#Sending%20Datagrams">Sending Datagrams</a>:     Sending packets on a datagram socket. 
-<li><a href="#Receiving%20Datagrams">Receiving Datagrams</a>:   Receiving packets on a datagram socket. 
-<li><a href="#Datagram%20Example">Datagram Example</a>:      An example program: packets sent over a
+</p><li><a href="#Sending Datagrams">Sending Datagrams</a>:     Sending packets on a datagram socket. 
+<li><a href="#Receiving Datagrams">Receiving Datagrams</a>:   Receiving packets on a datagram socket. 
+<li><a href="#Datagram Example">Datagram Example</a>:      An example program: packets sent over a
                            datagram socket in the local namespace. 
-<li><a href="#Example%20Receiver">Example Receiver</a>: 	 Another program, that receives those packets.
+<li><a href="#Example Receiver">Example Receiver</a>: 	 Another program, that receives those packets.
 
 <p>Inetd
 
-</p><li><a href="#Inetd%20Servers">Inetd Servers</a>: 
-<li><a href="#Configuring%20Inetd">Configuring Inetd</a>:
+</p><li><a href="#Inetd Servers">Inetd Servers</a>: 
+<li><a href="#Configuring Inetd">Configuring Inetd</a>:
 
 <p>Socket Options
 
-</p><li><a href="#Socket%20Option%20Functions">Socket Option Functions</a>:      The basic functions for setting and getting
+</p><li><a href="#Socket Option Functions">Socket Option Functions</a>:      The basic functions for setting and getting
                                  socket options. 
-<li><a href="#Socket-Level%20Options">Socket-Level Options</a>:         Details of the options at the socket level.
+<li><a href="#Socket-Level Options">Socket-Level Options</a>:         Details of the options at the socket level.
 
 <p>Low-Level Terminal Interface
 
-</p><li><a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>:             How to determine if a file is a terminal
+</p><li><a href="#Is It a Terminal">Is It a Terminal</a>:             How to determine if a file is a terminal
 			         device, and what its name is. 
-<li><a href="#I%2fO%20Queues">I/O Queues</a>:                   About flow control and typeahead. 
-<li><a href="#Canonical%20or%20Not">Canonical or Not</a>:             Two basic styles of input processing. 
-<li><a href="#Terminal%20Modes">Terminal Modes</a>:               How to examine and modify flags controlling
+<li><a href="#I%2fO Queues">I/O Queues</a>:                   About flow control and typeahead. 
+<li><a href="#Canonical or Not">Canonical or Not</a>:             Two basic styles of input processing. 
+<li><a href="#Terminal Modes">Terminal Modes</a>:               How to examine and modify flags controlling
 			         details of terminal I/O: echoing,
                                  signals, editing.  Posix. 
-<li><a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>:           BSD compatible terminal mode setting
-<li><a href="#Line%20Control">Line Control</a>:                 Sending break sequences, clearing
+<li><a href="#BSD Terminal Modes">BSD Terminal Modes</a>:           BSD compatible terminal mode setting
+<li><a href="#Line Control">Line Control</a>:                 Sending break sequences, clearing
                                  terminal buffers <small>...</small>
-<li><a href="#Noncanon%20Example">Noncanon Example</a>:             How to read single characters without echo. 
+<li><a href="#Noncanon Example">Noncanon Example</a>:             How to read single characters without echo. 
 <li><a href="#Pseudo-Terminals">Pseudo-Terminals</a>:             How to open a pseudo-terminal.
 
 <p>Terminal Modes
 
-</p><li><a href="#Mode%20Data%20Types">Mode Data Types</a>:              The data type <code>struct termios</code> and
+</p><li><a href="#Mode Data Types">Mode Data Types</a>:              The data type <code>struct termios</code> and
                                  related types. 
-<li><a href="#Mode%20Functions">Mode Functions</a>:               Functions to read and set the terminal
+<li><a href="#Mode Functions">Mode Functions</a>:               Functions to read and set the terminal
                                  attributes. 
-<li><a href="#Setting%20Modes">Setting Modes</a>:                The right way to set terminal attributes
+<li><a href="#Setting Modes">Setting Modes</a>:                The right way to set terminal attributes
                                  reliably. 
-<li><a href="#Input%20Modes">Input Modes</a>:                  Flags controlling low-level input handling. 
-<li><a href="#Output%20Modes">Output Modes</a>:                 Flags controlling low-level output handling. 
-<li><a href="#Control%20Modes">Control Modes</a>:                Flags controlling serial port behavior. 
-<li><a href="#Local%20Modes">Local Modes</a>:                  Flags controlling high-level input handling. 
-<li><a href="#Line%20Speed">Line Speed</a>:                   How to read and set the terminal line speed. 
-<li><a href="#Special%20Characters">Special Characters</a>:           Characters that have special effects,
+<li><a href="#Input Modes">Input Modes</a>:                  Flags controlling low-level input handling. 
+<li><a href="#Output Modes">Output Modes</a>:                 Flags controlling low-level output handling. 
+<li><a href="#Control Modes">Control Modes</a>:                Flags controlling serial port behavior. 
+<li><a href="#Local Modes">Local Modes</a>:                  Flags controlling high-level input handling. 
+<li><a href="#Line Speed">Line Speed</a>:                   How to read and set the terminal line speed. 
+<li><a href="#Special Characters">Special Characters</a>:           Characters that have special effects,
 			         and how to change them. 
-<li><a href="#Noncanonical%20Input">Noncanonical Input</a>:           Controlling how long to wait for input.
+<li><a href="#Noncanonical Input">Noncanonical Input</a>:           Controlling how long to wait for input.
 
 <p>Special Characters
 
-</p><li><a href="#Editing%20Characters">Editing Characters</a>:           Special characters that terminate lines and
+</p><li><a href="#Editing Characters">Editing Characters</a>:           Special characters that terminate lines and
                                   delete text, and other editing functions. 
-<li><a href="#Signal%20Characters">Signal Characters</a>:            Special characters that send or raise signals
+<li><a href="#Signal Characters">Signal Characters</a>:            Special characters that send or raise signals
                                   to or for certain classes of processes. 
-<li><a href="#Start%2fStop%20Characters">Start/Stop Characters</a>:        Special characters that suspend or resume
+<li><a href="#Start%2fStop Characters">Start/Stop Characters</a>:        Special characters that suspend or resume
                                   suspended output. 
-<li><a href="#Other%20Special">Other Special</a>: 		Other special characters for BSD systems:
+<li><a href="#Other Special">Other Special</a>: 		Other special characters for BSD systems:
 				  they can discard output, and print status.
 
 <p>Pseudo-Terminals
 
 </p><li><a href="#Allocation">Allocation</a>:              Allocating a pseudo terminal. 
-<li><a href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>:   How to open both sides of a
+<li><a href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>:   How to open both sides of a
                             pseudo-terminal in a single operation.
 
 <p>Syslog
 
-</p><li><a href="#Overview%20of%20Syslog">Overview of Syslog</a>:            Overview of a system's Syslog facility
-<li><a href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>:    Functions to submit messages to Syslog
+</p><li><a href="#Overview of Syslog">Overview of Syslog</a>:            Overview of a system's Syslog facility
+<li><a href="#Submitting Syslog Messages">Submitting Syslog Messages</a>:    Functions to submit messages to Syslog
 
 <p>Submitting Syslog Messages
 
 </p><li><a href="#openlog">openlog</a>:                       Open connection to Syslog
-<li><a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>:               Submit message to Syslog
+<li><a href="#syslog%3b vsyslog">syslog; vsyslog</a>:               Submit message to Syslog
 <li><a href="#closelog">closelog</a>:                      Close connection to Syslog
 <li><a href="#setlogmask">setlogmask</a>:                    Cause certain messages to be ignored
-<li><a href="#Syslog%20Example">Syslog Example</a>:                Example of all of the above
+<li><a href="#Syslog Example">Syslog Example</a>:                Example of all of the above
 
 <p>Mathematics
 
-</p><li><a href="#Mathematical%20Constants">Mathematical Constants</a>:       Precise numeric values for often-used
+</p><li><a href="#Mathematical Constants">Mathematical Constants</a>:       Precise numeric values for often-used
                                  constants. 
-<li><a href="#Trig%20Functions">Trig Functions</a>:               Sine, cosine, tangent, and friends. 
-<li><a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>:       Arcsine, arccosine, etc. 
-<li><a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>:     Also pow and sqrt. 
-<li><a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>:         sinh, cosh, tanh, etc. 
-<li><a href="#Special%20Functions">Special Functions</a>:            Bessel, gamma, erf. 
-<li><a href="#Errors%20in%20Math%20Functions">Errors in Math Functions</a>:     Known Maximum Errors in Math Functions. 
-<li><a href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>:        Functions for generating pseudo-random
+<li><a href="#Trig Functions">Trig Functions</a>:               Sine, cosine, tangent, and friends. 
+<li><a href="#Inverse Trig Functions">Inverse Trig Functions</a>:       Arcsine, arccosine, etc. 
+<li><a href="#Exponents and Logarithms">Exponents and Logarithms</a>:     Also pow and sqrt. 
+<li><a href="#Hyperbolic Functions">Hyperbolic Functions</a>:         sinh, cosh, tanh, etc. 
+<li><a href="#Special Functions">Special Functions</a>:            Bessel, gamma, erf. 
+<li><a href="#Errors in Math Functions">Errors in Math Functions</a>:     Known Maximum Errors in Math Functions. 
+<li><a href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>:        Functions for generating pseudo-random
 				 numbers. 
-<li><a href="#FP%20Function%20Optimizations">FP Function Optimizations</a>:    Fast code or small code.
+<li><a href="#FP Function Optimizations">FP Function Optimizations</a>:    Fast code or small code.
 
 <p>Pseudo-Random Numbers
 
-</p><li><a href="#ISO%20Random">ISO Random</a>:                   <code>rand</code> and friends. 
-<li><a href="#BSD%20Random">BSD Random</a>:                   <code>random</code> and friends. 
-<li><a href="#SVID%20Random">SVID Random</a>:                  <code>drand48</code> and friends.
+</p><li><a href="#ISO Random">ISO Random</a>:                   <code>rand</code> and friends. 
+<li><a href="#BSD Random">BSD Random</a>:                   <code>random</code> and friends. 
+<li><a href="#SVID Random">SVID Random</a>:                  <code>drand48</code> and friends.
 
 <p>Arithmetic
 
 </p><li><a href="#Integers">Integers</a>:                     Basic integer types and concepts
-<li><a href="#Integer%20Division">Integer Division</a>:             Integer division with guaranteed rounding. 
-<li><a href="#Floating%20Point%20Numbers">Floating Point Numbers</a>:       Basic concepts.  IEEE 754. 
-<li><a href="#Floating%20Point%20Classes">Floating Point Classes</a>:       The five kinds of floating-point number. 
-<li><a href="#Floating%20Point%20Errors">Floating Point Errors</a>:        When something goes wrong in a calculation. 
+<li><a href="#Integer Division">Integer Division</a>:             Integer division with guaranteed rounding. 
+<li><a href="#Floating Point Numbers">Floating Point Numbers</a>:       Basic concepts.  IEEE 754. 
+<li><a href="#Floating Point Classes">Floating Point Classes</a>:       The five kinds of floating-point number. 
+<li><a href="#Floating Point Errors">Floating Point Errors</a>:        When something goes wrong in a calculation. 
 <li><a href="#Rounding">Rounding</a>:                     Controlling how results are rounded. 
-<li><a href="#Control%20Functions">Control Functions</a>:            Saving and restoring the FPU's state. 
-<li><a href="#Arithmetic%20Functions">Arithmetic Functions</a>:         Fundamental operations provided by the library. 
-<li><a href="#Complex%20Numbers">Complex Numbers</a>:              The types.  Writing complex constants. 
-<li><a href="#Operations%20on%20Complex">Operations on Complex</a>:        Projection, conjugation, decomposition. 
-<li><a href="#Parsing%20of%20Numbers">Parsing of Numbers</a>:           Converting strings to numbers. 
-<li><a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>:   An archaic way to convert numbers to strings.
+<li><a href="#Control Functions">Control Functions</a>:            Saving and restoring the FPU's state. 
+<li><a href="#Arithmetic Functions">Arithmetic Functions</a>:         Fundamental operations provided by the library. 
+<li><a href="#Complex Numbers">Complex Numbers</a>:              The types.  Writing complex constants. 
+<li><a href="#Operations on Complex">Operations on Complex</a>:        Projection, conjugation, decomposition. 
+<li><a href="#Parsing of Numbers">Parsing of Numbers</a>:           Converting strings to numbers. 
+<li><a href="#System V Number Conversion">System V Number Conversion</a>:   An archaic way to convert numbers to strings.
 
 <p>Floating Point Errors
 
-</p><li><a href="#FP%20Exceptions">FP Exceptions</a>:                IEEE 754 math exceptions and how to detect them. 
-<li><a href="#Infinity%20and%20NaN">Infinity and NaN</a>:             Special values returned by calculations. 
-<li><a href="#Status%20bit%20operations">Status bit operations</a>:        Checking for exceptions after the fact. 
-<li><a href="#Math%20Error%20Reporting">Math Error Reporting</a>:         How the math functions report errors.
+</p><li><a href="#FP Exceptions">FP Exceptions</a>:                IEEE 754 math exceptions and how to detect them. 
+<li><a href="#Infinity and NaN">Infinity and NaN</a>:             Special values returned by calculations. 
+<li><a href="#Status bit operations">Status bit operations</a>:        Checking for exceptions after the fact. 
+<li><a href="#Math Error Reporting">Math Error Reporting</a>:         How the math functions report errors.
 
 <p>Arithmetic Functions
 
-</p><li><a href="#Absolute%20Value">Absolute Value</a>:               Absolute values of integers and floats. 
-<li><a href="#Normalization%20Functions">Normalization Functions</a>:      Extracting exponents and putting them back. 
-<li><a href="#Rounding%20Functions">Rounding Functions</a>:           Rounding floats to integers. 
-<li><a href="#Remainder%20Functions">Remainder Functions</a>:          Remainders on division, precisely defined. 
-<li><a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>:             Sign bit adjustment.  Adding epsilon. 
-<li><a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>:      Comparisons without risk of exceptions. 
-<li><a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>:           Max, min, positive difference, multiply-add.
+</p><li><a href="#Absolute Value">Absolute Value</a>:               Absolute values of integers and floats. 
+<li><a href="#Normalization Functions">Normalization Functions</a>:      Extracting exponents and putting them back. 
+<li><a href="#Rounding Functions">Rounding Functions</a>:           Rounding floats to integers. 
+<li><a href="#Remainder Functions">Remainder Functions</a>:          Remainders on division, precisely defined. 
+<li><a href="#FP Bit Twiddling">FP Bit Twiddling</a>:             Sign bit adjustment.  Adding epsilon. 
+<li><a href="#FP Comparison Functions">FP Comparison Functions</a>:      Comparisons without risk of exceptions. 
+<li><a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>:           Max, min, positive difference, multiply-add.
 
 <p>Parsing of Numbers
 
-</p><li><a href="#Parsing%20of%20Integers">Parsing of Integers</a>:          Functions for conversion of integer values. 
-<li><a href="#Parsing%20of%20Floats">Parsing of Floats</a>:            Functions for conversion of floating-point
+</p><li><a href="#Parsing of Integers">Parsing of Integers</a>:          Functions for conversion of integer values. 
+<li><a href="#Parsing of Floats">Parsing of Floats</a>:            Functions for conversion of floating-point
 				 values.
 
 <p>Date and Time
 
-</p><li><a href="#Time%20Basics">Time Basics</a>:                  Concepts and definitions. 
-<li><a href="#Elapsed%20Time">Elapsed Time</a>:                 Data types to represent elapsed times
-<li><a href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>:       Time a program has spent executing. 
-<li><a href="#Calendar%20Time">Calendar Time</a>:                Manipulation of ``real'' dates and times. 
-<li><a href="#Setting%20an%20Alarm">Setting an Alarm</a>:             Sending a signal after a specified time. 
+</p><li><a href="#Time Basics">Time Basics</a>:                  Concepts and definitions. 
+<li><a href="#Elapsed Time">Elapsed Time</a>:                 Data types to represent elapsed times
+<li><a href="#Processor And CPU Time">Processor And CPU Time</a>:       Time a program has spent executing. 
+<li><a href="#Calendar Time">Calendar Time</a>:                Manipulation of "real" dates and times. 
+<li><a href="#Setting an Alarm">Setting an Alarm</a>:             Sending a signal after a specified time. 
 <li><a href="#Sleeping">Sleeping</a>:                     Waiting for a period of time.
 
 <p>Processor And CPU Time
 
-</p><li><a href="#CPU%20Time">CPU Time</a>:                     The <code>clock</code> function. 
-<li><a href="#Processor%20Time">Processor Time</a>:               The <code>times</code> function.
+</p><li><a href="#CPU Time">CPU Time</a>:                     The <code>clock</code> function. 
+<li><a href="#Processor Time">Processor Time</a>:               The <code>times</code> function.
 
 <p>Calendar Time
 
-</p><li><a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>:         Facilities for manipulating calendar time. 
-<li><a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>:     A time representation with greater precision. 
-<li><a href="#Broken-down%20Time">Broken-down Time</a>:             Facilities for manipulating local time. 
-<li><a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>:          Maintaining a high accuracy system clock. 
-<li><a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>:     Converting times to strings. 
-<li><a href="#Parsing%20Date%20and%20Time">Parsing Date and Time</a>:        Convert textual time and date information back
+</p><li><a href="#Simple Calendar Time">Simple Calendar Time</a>:         Facilities for manipulating calendar time. 
+<li><a href="#High-Resolution Calendar">High-Resolution Calendar</a>:     A time representation with greater precision. 
+<li><a href="#Broken-down Time">Broken-down Time</a>:             Facilities for manipulating local time. 
+<li><a href="#High Accuracy Clock">High Accuracy Clock</a>:          Maintaining a high accuracy system clock. 
+<li><a href="#Formatting Calendar Time">Formatting Calendar Time</a>:     Converting times to strings. 
+<li><a href="#Parsing Date and Time">Parsing Date and Time</a>:        Convert textual time and date information back
                                  into broken-down time values. 
-<li><a href="#TZ%20Variable">TZ Variable</a>:                  How users specify the time zone. 
-<li><a href="#Time%20Zone%20Functions">Time Zone Functions</a>:          Functions to examine or specify the time zone. 
-<li><a href="#Time%20Functions%20Example">Time Functions Example</a>:       An example program showing use of some of
+<li><a href="#TZ Variable">TZ Variable</a>:                  How users specify the time zone. 
+<li><a href="#Time Zone Functions">Time Zone Functions</a>:          Functions to examine or specify the time zone. 
+<li><a href="#Time Functions Example">Time Functions Example</a>:       An example program showing use of some of
 				 the time functions.
 
 <p>Parsing Date and Time
 
-</p><li><a href="#Low-Level%20Time%20String%20Parsing">Low-Level Time String Parsing</a>:   Interpret string according to given format. 
-<li><a href="#General%20Time%20String%20Parsing">General Time String Parsing</a>:     User-friendly function to parse data and
+</p><li><a href="#Low-Level Time String Parsing">Low-Level Time String Parsing</a>:   Interpret string according to given format. 
+<li><a href="#General Time String Parsing">General Time String Parsing</a>:     User-friendly function to parse data and
                                     time strings.
 
 <p>Resource Usage And Limitation
 
-</p><li><a href="#Resource%20Usage">Resource Usage</a>: 		Measuring various resources used. 
-<li><a href="#Limits%20on%20Resources">Limits on Resources</a>: 		Specifying limits on resource usage. 
+</p><li><a href="#Resource Usage">Resource Usage</a>: 		Measuring various resources used. 
+<li><a href="#Limits on Resources">Limits on Resources</a>: 		Specifying limits on resource usage. 
 <li><a href="#Priority">Priority</a>: 			Reading or setting process run priority. 
-<li><a href="#Memory%20Resources">Memory Resources</a>:             Querying memory available resources. 
-<li><a href="#Processor%20Resources">Processor Resources</a>:          Learn about the processors available.
+<li><a href="#Memory Resources">Memory Resources</a>:             Querying memory available resources. 
+<li><a href="#Processor Resources">Processor Resources</a>:          Learn about the processors available.
 
 <p>Priority
 
-</p><li><a href="#Absolute%20Priority">Absolute Priority</a>:                The first tier of priority.  Posix
-<li><a href="#Realtime%20Scheduling">Realtime Scheduling</a>:              Scheduling among the process nobility
-<li><a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>:       Get/set scheduling policy, priority
-<li><a href="#Traditional%20Scheduling">Traditional Scheduling</a>:           Scheduling among the vulgar masses
+</p><li><a href="#Absolute Priority">Absolute Priority</a>:                The first tier of priority.  Posix
+<li><a href="#Realtime Scheduling">Realtime Scheduling</a>:              Scheduling among the process nobility
+<li><a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>:       Get/set scheduling policy, priority
+<li><a href="#Traditional Scheduling">Traditional Scheduling</a>:           Scheduling among the vulgar masses
 
 <p>Traditional Scheduling
 
-</p><li><a href="#Traditional%20Scheduling%20Intro">Traditional Scheduling Intro</a>: 
-<li><a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>:
+</p><li><a href="#Traditional Scheduling Intro">Traditional Scheduling Intro</a>: 
+<li><a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>:
 
 <p>Memory Resources
 
-</p><li><a href="#Memory%20Subsystem">Memory Subsystem</a>:            Overview about traditional Unix memory handling. 
-<li><a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>:     How to get information about the memory
+</p><li><a href="#Memory Subsystem">Memory Subsystem</a>:            Overview about traditional Unix memory handling. 
+<li><a href="#Query Memory Parameters">Query Memory Parameters</a>:     How to get information about the memory
                                 subsystem?
 
 <p>Non-Local Exits
 
-</p><li><a href="#Non-Local%20Intro">Intro</a>:         When and how to use these facilities. 
-<li><a href="#Non-Local%20Details">Details</a>:     Functions for non-local exits. 
-<li><a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>:   Portability issues. 
-<li><a href="#System%20V%20contexts">System V contexts</a>:             Complete context control a la System V.
+</p><li><a href="#Non-Local Intro">Intro</a>:         When and how to use these facilities. 
+<li><a href="#Non-Local Details">Details</a>:     Functions for non-local exits. 
+<li><a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>:   Portability issues. 
+<li><a href="#System V contexts">System V contexts</a>:             Complete context control a la System V.
 
 <p>Signal Handling
 
-</p><li><a href="#Concepts%20of%20Signals">Concepts of Signals</a>:          Introduction to the signal facilities. 
-<li><a href="#Standard%20Signals">Standard Signals</a>:             Particular kinds of signals with
+</p><li><a href="#Concepts of Signals">Concepts of Signals</a>:          Introduction to the signal facilities. 
+<li><a href="#Standard Signals">Standard Signals</a>:             Particular kinds of signals with
                                  standard names and meanings. 
-<li><a href="#Signal%20Actions">Signal Actions</a>:               Specifying what happens when a
+<li><a href="#Signal Actions">Signal Actions</a>:               Specifying what happens when a
                                  particular signal is delivered. 
-<li><a href="#Defining%20Handlers">Defining Handlers</a>:            How to write a signal handler function. 
-<li><a href="#Interrupted%20Primitives">Interrupted Primitives</a>: 	Signal handlers affect use of <code>open</code>,
+<li><a href="#Defining Handlers">Defining Handlers</a>:            How to write a signal handler function. 
+<li><a href="#Interrupted Primitives">Interrupted Primitives</a>: 	Signal handlers affect use of <code>open</code>,
 				 <code>read</code>, <code>write</code> and other functions. 
-<li><a href="#Generating%20Signals">Generating Signals</a>:           How to send a signal to a process. 
-<li><a href="#Blocking%20Signals">Blocking Signals</a>:             Making the system hold signals temporarily. 
-<li><a href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>:         Suspending your program until a signal
+<li><a href="#Generating Signals">Generating Signals</a>:           How to send a signal to a process. 
+<li><a href="#Blocking Signals">Blocking Signals</a>:             Making the system hold signals temporarily. 
+<li><a href="#Waiting for a Signal">Waiting for a Signal</a>:         Suspending your program until a signal
                                  arrives. 
-<li><a href="#Signal%20Stack">Signal Stack</a>:                 Using a Separate Signal Stack. 
-<li><a href="#BSD%20Signal%20Handling">BSD Signal Handling</a>:          Additional functions for backward
+<li><a href="#Signal Stack">Signal Stack</a>:                 Using a Separate Signal Stack. 
+<li><a href="#BSD Signal Handling">BSD Signal Handling</a>:          Additional functions for backward
 			         compatibility with BSD.
 
 <p>Concepts of Signals
 
-</p><li><a href="#Kinds%20of%20Signals">Kinds of Signals</a>:             Some examples of what can cause a signal. 
-<li><a href="#Signal%20Generation">Signal Generation</a>:            Concepts of why and how signals occur. 
-<li><a href="#Delivery%20of%20Signal">Delivery of Signal</a>:           Concepts of what a signal does to the
+</p><li><a href="#Kinds of Signals">Kinds of Signals</a>:             Some examples of what can cause a signal. 
+<li><a href="#Signal Generation">Signal Generation</a>:            Concepts of why and how signals occur. 
+<li><a href="#Delivery of Signal">Delivery of Signal</a>:           Concepts of what a signal does to the
                                  process.
 
 <p>Standard Signals
 
-</p><li><a href="#Program%20Error%20Signals">Program Error Signals</a>:        Used to report serious program errors. 
-<li><a href="#Termination%20Signals">Termination Signals</a>:          Used to interrupt and/or terminate the
+</p><li><a href="#Program Error Signals">Program Error Signals</a>:        Used to report serious program errors. 
+<li><a href="#Termination Signals">Termination Signals</a>:          Used to interrupt and/or terminate the
                                  program. 
-<li><a href="#Alarm%20Signals">Alarm Signals</a>:                Used to indicate expiration of timers. 
-<li><a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>:     Used to indicate input is available. 
-<li><a href="#Job%20Control%20Signals">Job Control Signals</a>:          Signals used to support job control. 
-<li><a href="#Operation%20Error%20Signals">Operation Error Signals</a>:      Used to report operational system errors. 
-<li><a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>:        Miscellaneous Signals. 
-<li><a href="#Signal%20Messages">Signal Messages</a>:              Printing a message describing a signal.
+<li><a href="#Alarm Signals">Alarm Signals</a>:                Used to indicate expiration of timers. 
+<li><a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>:     Used to indicate input is available. 
+<li><a href="#Job Control Signals">Job Control Signals</a>:          Signals used to support job control. 
+<li><a href="#Operation Error Signals">Operation Error Signals</a>:      Used to report operational system errors. 
+<li><a href="#Miscellaneous Signals">Miscellaneous Signals</a>:        Miscellaneous Signals. 
+<li><a href="#Signal Messages">Signal Messages</a>:              Printing a message describing a signal.
 
 <p>Signal Actions
 
-</p><li><a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>:        The simple <code>signal</code> function. 
-<li><a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>:     The more powerful <code>sigaction</code> function. 
-<li><a href="#Signal%20and%20Sigaction">Signal and Sigaction</a>:         How those two functions interact. 
-<li><a href="#Sigaction%20Function%20Example">Sigaction Function Example</a>:   An example of using the sigaction function. 
-<li><a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>:          Specifying options for signal handling. 
-<li><a href="#Initial%20Signal%20Actions">Initial Signal Actions</a>:       How programs inherit signal actions.
+</p><li><a href="#Basic Signal Handling">Basic Signal Handling</a>:        The simple <code>signal</code> function. 
+<li><a href="#Advanced Signal Handling">Advanced Signal Handling</a>:     The more powerful <code>sigaction</code> function. 
+<li><a href="#Signal and Sigaction">Signal and Sigaction</a>:         How those two functions interact. 
+<li><a href="#Sigaction Function Example">Sigaction Function Example</a>:   An example of using the sigaction function. 
+<li><a href="#Flags for Sigaction">Flags for Sigaction</a>:          Specifying options for signal handling. 
+<li><a href="#Initial Signal Actions">Initial Signal Actions</a>:       How programs inherit signal actions.
 
 <p>Defining Handlers
 
-</p><li><a href="#Handler%20Returns">Handler Returns</a>:              Handlers that return normally, and what
+</p><li><a href="#Handler Returns">Handler Returns</a>:              Handlers that return normally, and what
                                  this means. 
-<li><a href="#Termination%20in%20Handler">Termination in Handler</a>:       How handler functions terminate a program. 
-<li><a href="#Longjmp%20in%20Handler">Longjmp in Handler</a>:           Nonlocal transfer of control out of a
+<li><a href="#Termination in Handler">Termination in Handler</a>:       How handler functions terminate a program. 
+<li><a href="#Longjmp in Handler">Longjmp in Handler</a>:           Nonlocal transfer of control out of a
                                  signal handler. 
-<li><a href="#Signals%20in%20Handler">Signals in Handler</a>:           What happens when signals arrive while
+<li><a href="#Signals in Handler">Signals in Handler</a>:           What happens when signals arrive while
                                  the handler is already occupied. 
-<li><a href="#Merged%20Signals">Merged Signals</a>: 		When a second signal arrives before the
+<li><a href="#Merged Signals">Merged Signals</a>: 		When a second signal arrives before the
 				 first is handled. 
 <li><a href="#Nonreentrancy">Nonreentrancy</a>:                Do not call any functions unless you know they
                                  are reentrant with respect to signals. 
-<li><a href="#Atomic%20Data%20Access">Atomic Data Access</a>:           A single handler can run in the middle of
+<li><a href="#Atomic Data Access">Atomic Data Access</a>:           A single handler can run in the middle of
                                  reading or writing a single object.
 
 <p>Atomic Data Access
 
-</p><li><a href="#Non-atomic%20Example">Non-atomic Example</a>: 		A program illustrating interrupted access. 
-<li><a href="#Atomic%20Types">Types</a>: 		Data types that guarantee no interruption. 
-<li><a href="#Atomic%20Usage">Usage</a>: 		Proving that interruption is harmless.
+</p><li><a href="#Non-atomic Example">Non-atomic Example</a>: 		A program illustrating interrupted access. 
+<li><a href="#Atomic Types">Types</a>: 		Data types that guarantee no interruption. 
+<li><a href="#Atomic Usage">Usage</a>: 		Proving that interruption is harmless.
 
 <p>Generating Signals
 
-</p><li><a href="#Signaling%20Yourself">Signaling Yourself</a>:           A process can send a signal to itself. 
-<li><a href="#Signaling%20Another%20Process">Signaling Another Process</a>:    Send a signal to another process. 
-<li><a href="#Permission%20for%20kill">Permission for kill</a>:          Permission for using <code>kill</code>. 
-<li><a href="#Kill%20Example">Kill Example</a>:                 Using <code>kill</code> for Communication.
+</p><li><a href="#Signaling Yourself">Signaling Yourself</a>:           A process can send a signal to itself. 
+<li><a href="#Signaling Another Process">Signaling Another Process</a>:    Send a signal to another process. 
+<li><a href="#Permission for kill">Permission for kill</a>:          Permission for using <code>kill</code>. 
+<li><a href="#Kill Example">Kill Example</a>:                 Using <code>kill</code> for Communication.
 
 <p>Blocking Signals
 
-</p><li><a href="#Why%20Block">Why Block</a>:                            The purpose of blocking signals. 
-<li><a href="#Signal%20Sets">Signal Sets</a>:                          How to specify which signals to
+</p><li><a href="#Why Block">Why Block</a>:                            The purpose of blocking signals. 
+<li><a href="#Signal Sets">Signal Sets</a>:                          How to specify which signals to
                                          block. 
-<li><a href="#Process%20Signal%20Mask">Process Signal Mask</a>:                  Blocking delivery of signals to your
+<li><a href="#Process Signal Mask">Process Signal Mask</a>:                  Blocking delivery of signals to your
 				         process during normal execution. 
-<li><a href="#Testing%20for%20Delivery">Testing for Delivery</a>:                 Blocking to Test for Delivery of
+<li><a href="#Testing for Delivery">Testing for Delivery</a>:                 Blocking to Test for Delivery of
                                          a Signal. 
-<li><a href="#Blocking%20for%20Handler">Blocking for Handler</a>:                 Blocking additional signals while a
+<li><a href="#Blocking for Handler">Blocking for Handler</a>:                 Blocking additional signals while a
 				         handler is being run. 
-<li><a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>:         Checking for Pending Signals
-<li><a href="#Remembering%20a%20Signal">Remembering a Signal</a>:                 How you can get almost the same
+<li><a href="#Checking for Pending Signals">Checking for Pending Signals</a>:         Checking for Pending Signals
+<li><a href="#Remembering a Signal">Remembering a Signal</a>:                 How you can get almost the same
                                          effect as blocking a signal, by
                                          handling it and setting a flag
                                          to be tested later.
 
 <p>Waiting for a Signal
 
-</p><li><a href="#Using%20Pause">Using Pause</a>:                  The simple way, using <code>pause</code>. 
-<li><a href="#Pause%20Problems">Pause Problems</a>:               Why the simple way is often not very good. 
+</p><li><a href="#Using Pause">Using Pause</a>:                  The simple way, using <code>pause</code>. 
+<li><a href="#Pause Problems">Pause Problems</a>:               Why the simple way is often not very good. 
 <li><a href="#Sigsuspend">Sigsuspend</a>:                   Reliably waiting for a specific signal.
 
 <p>BSD Signal Handling
 
-</p><li><a href="#BSD%20Handler">BSD Handler</a>:                  BSD Function to Establish a Handler. 
-<li><a href="#Blocking%20in%20BSD">Blocking in BSD</a>:              BSD Functions for Blocking Signals.
+</p><li><a href="#BSD Handler">BSD Handler</a>:                  BSD Function to Establish a Handler. 
+<li><a href="#Blocking in BSD">Blocking in BSD</a>:              BSD Functions for Blocking Signals.
 
 <p>Program Basics
 
-</p><li><a href="#Program%20Arguments">Program Arguments</a>:            Parsing your program's command-line arguments. 
-<li><a href="#Environment%20Variables">Environment Variables</a>:        Less direct parameters affecting your program
-<li><a href="#System%20Calls">System Calls</a>:                 Requesting service from the system
-<li><a href="#Program%20Termination">Program Termination</a>:          Telling the system you're done; return status
+</p><li><a href="#Program Arguments">Program Arguments</a>:            Parsing your program's command-line arguments. 
+<li><a href="#Environment Variables">Environment Variables</a>:        Less direct parameters affecting your program
+<li><a href="#System Calls">System Calls</a>:                 Requesting service from the system
+<li><a href="#Program Termination">Program Termination</a>:          Telling the system you're done; return status
 
 <p>Program Arguments
 
-</p><li><a href="#Argument%20Syntax">Argument Syntax</a>:              By convention, options start with a hyphen. 
-<li><a href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>:    Ways to parse program options and arguments.
+</p><li><a href="#Argument Syntax">Argument Syntax</a>:              By convention, options start with a hyphen. 
+<li><a href="#Parsing Program Arguments">Parsing Program Arguments</a>:    Ways to parse program options and arguments.
 
 <p>Parsing Program Arguments
 
 </p><li><a href="#Getopt">Getopt</a>:                       Parsing program options using <code>getopt</code>. 
 <li><a href="#Argp">Argp</a>:                         Parsing program options using <code>argp_parse</code>. 
 <li><a href="#Suboptions">Suboptions</a>:                   Some programs need more detailed options. 
-<li><a href="#Suboptions%20Example">Suboptions Example</a>:           This shows how it could be done for <code>mount</code>.
+<li><a href="#Suboptions Example">Suboptions Example</a>:           This shows how it could be done for <code>mount</code>.
 
 <p>Environment Variables
 
-</p><li><a href="#Environment%20Access">Environment Access</a>:           How to get and set the values of
+</p><li><a href="#Environment Access">Environment Access</a>:           How to get and set the values of
 				 environment variables. 
-<li><a href="#Standard%20Environment">Standard Environment</a>:         These environment variables have
+<li><a href="#Standard Environment">Standard Environment</a>:         These environment variables have
                 		 standard interpretations.
 
 <p>Program Termination
 
-</p><li><a href="#Normal%20Termination">Normal Termination</a>:           If a program calls <code>exit</code>, a
+</p><li><a href="#Normal Termination">Normal Termination</a>:           If a program calls <code>exit</code>, a
                                  process terminates normally. 
-<li><a href="#Exit%20Status">Exit Status</a>:                  The <code>exit status</code> provides information
+<li><a href="#Exit Status">Exit Status</a>:                  The <code>exit status</code> provides information
                                  about why the process terminated. 
-<li><a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>:             A process can run its own cleanup
+<li><a href="#Cleanups on Exit">Cleanups on Exit</a>:             A process can run its own cleanup
                                  functions upon normal termination. 
-<li><a href="#Aborting%20a%20Program">Aborting a Program</a>:           The <code>abort</code> function causes
+<li><a href="#Aborting a Program">Aborting a Program</a>:           The <code>abort</code> function causes
                                  abnormal program termination. 
-<li><a href="#Termination%20Internals">Termination Internals</a>:        What happens when a process terminates.
+<li><a href="#Termination Internals">Termination Internals</a>:        What happens when a process terminates.
 
 <p>Processes
 
-</p><li><a href="#Running%20a%20Command">Running a Command</a>:            The easy way to run another program. 
-<li><a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>:    An overview of the hard way to do it. 
-<li><a href="#Process%20Identification">Process Identification</a>:       How to get the process ID of a process. 
-<li><a href="#Creating%20a%20Process">Creating a Process</a>:           How to fork a child process. 
-<li><a href="#Executing%20a%20File">Executing a File</a>:             How to make a process execute another program. 
-<li><a href="#Process%20Completion">Process Completion</a>:           How to tell when a child process has completed. 
-<li><a href="#Process%20Completion%20Status">Process Completion Status</a>:    How to interpret the status value
+</p><li><a href="#Running a Command">Running a Command</a>:            The easy way to run another program. 
+<li><a href="#Process Creation Concepts">Process Creation Concepts</a>:    An overview of the hard way to do it. 
+<li><a href="#Process Identification">Process Identification</a>:       How to get the process ID of a process. 
+<li><a href="#Creating a Process">Creating a Process</a>:           How to fork a child process. 
+<li><a href="#Executing a File">Executing a File</a>:             How to make a process execute another program. 
+<li><a href="#Process Completion">Process Completion</a>:           How to tell when a child process has completed. 
+<li><a href="#Process Completion Status">Process Completion Status</a>:    How to interpret the status value
                                  returned from a child process. 
-<li><a href="#BSD%20Wait%20Functions">BSD Wait Functions</a>:   	More functions, for backward compatibility. 
-<li><a href="#Process%20Creation%20Example">Process Creation Example</a>:     A complete example program.
+<li><a href="#BSD Wait Functions">BSD Wait Functions</a>:   	More functions, for backward compatibility. 
+<li><a href="#Process Creation Example">Process Creation Example</a>:     A complete example program.
 
 <p>Job Control
 
-</p><li><a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>:      Jobs can be controlled by a shell. 
-<li><a href="#Job%20Control%20is%20Optional">Job Control is Optional</a>:      Not all POSIX systems support job control. 
-<li><a href="#Controlling%20Terminal">Controlling Terminal</a>:         How a process gets its controlling terminal. 
-<li><a href="#Access%20to%20the%20Terminal">Access to the Terminal</a>:       How processes share the controlling terminal. 
-<li><a href="#Orphaned%20Process%20Groups">Orphaned Process Groups</a>:      Jobs left after the user logs out. 
-<li><a href="#Implementing%20a%20Shell">Implementing a Shell</a>:         What a shell must do to implement job control. 
-<li><a href="#Functions%20for%20Job%20Control">Functions for Job Control</a>:    Functions to control process groups.
+</p><li><a href="#Concepts of Job Control">Concepts of Job Control</a>:      Jobs can be controlled by a shell. 
+<li><a href="#Job Control is Optional">Job Control is Optional</a>:      Not all POSIX systems support job control. 
+<li><a href="#Controlling Terminal">Controlling Terminal</a>:         How a process gets its controlling terminal. 
+<li><a href="#Access to the Terminal">Access to the Terminal</a>:       How processes share the controlling terminal. 
+<li><a href="#Orphaned Process Groups">Orphaned Process Groups</a>:      Jobs left after the user logs out. 
+<li><a href="#Implementing a Shell">Implementing a Shell</a>:         What a shell must do to implement job control. 
+<li><a href="#Functions for Job Control">Functions for Job Control</a>:    Functions to control process groups.
 
 <p>Implementing a Shell
 
-</p><li><a href="#Data%20Structures">Data Structures</a>:              Introduction to the sample shell. 
-<li><a href="#Initializing%20the%20Shell">Initializing the Shell</a>:       What the shell must do to take
+</p><li><a href="#Data Structures">Data Structures</a>:              Introduction to the sample shell. 
+<li><a href="#Initializing the Shell">Initializing the Shell</a>:       What the shell must do to take
 				 responsibility for job control. 
-<li><a href="#Launching%20Jobs">Launching Jobs</a>:               Creating jobs to execute commands. 
-<li><a href="#Foreground%20and%20Background">Foreground and Background</a>:    Putting a job in foreground of background. 
-<li><a href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>:   Reporting job status. 
-<li><a href="#Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>:      How to continue a stopped job in
+<li><a href="#Launching Jobs">Launching Jobs</a>:               Creating jobs to execute commands. 
+<li><a href="#Foreground and Background">Foreground and Background</a>:    Putting a job in foreground of background. 
+<li><a href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>:   Reporting job status. 
+<li><a href="#Continuing Stopped Jobs">Continuing Stopped Jobs</a>:      How to continue a stopped job in
 				 the foreground or background. 
-<li><a href="#Missing%20Pieces">Missing Pieces</a>:               Other parts of the shell.
+<li><a href="#Missing Pieces">Missing Pieces</a>:               Other parts of the shell.
 
 <p>Functions for Job Control
 
-</p><li><a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>:     Determining the controlling terminal's name. 
-<li><a href="#Process%20Group%20Functions">Process Group Functions</a>:      Functions for manipulating process groups. 
-<li><a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>:    Functions for controlling terminal access.
+</p><li><a href="#Identifying the Terminal">Identifying the Terminal</a>:     Determining the controlling terminal's name. 
+<li><a href="#Process Group Functions">Process Group Functions</a>:      Functions for manipulating process groups. 
+<li><a href="#Terminal Access Functions">Terminal Access Functions</a>:    Functions for controlling terminal access.
 
 <p>Name Service Switch
 
-</p><li><a href="#NSS%20Basics">NSS Basics</a>:                   What is this NSS good for. 
-<li><a href="#NSS%20Configuration%20File">NSS Configuration File</a>:       Configuring NSS. 
-<li><a href="#NSS%20Module%20Internals">NSS Module Internals</a>:         How does it work internally. 
-<li><a href="#Extending%20NSS">Extending NSS</a>:                What to do to add services or databases.
+</p><li><a href="#NSS Basics">NSS Basics</a>:                   What is this NSS good for. 
+<li><a href="#NSS Configuration File">NSS Configuration File</a>:       Configuring NSS. 
+<li><a href="#NSS Module Internals">NSS Module Internals</a>:         How does it work internally. 
+<li><a href="#Extending NSS">Extending NSS</a>:                What to do to add services or databases.
 
 <p>NSS Configuration File
 
-</p><li><a href="#Services%20in%20the%20NSS%20configuration">Services in the NSS configuration</a>:   Service names in the NSS configuration. 
-<li><a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>:   React appropriately to the lookup result. 
-<li><a href="#Notes%20on%20NSS%20Configuration%20File">Notes on NSS Configuration File</a>:   Things to take care about while
+</p><li><a href="#Services in the NSS configuration">Services in the NSS configuration</a>:   Service names in the NSS configuration. 
+<li><a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>:   React appropriately to the lookup result. 
+<li><a href="#Notes on NSS Configuration File">Notes on NSS Configuration File</a>:   Things to take care about while
                                      configuring NSS.
 
 <p>NSS Module Internals
 
-</p><li><a href="#NSS%20Module%20Names">NSS Module Names</a>:             Construction of the interface function of
+</p><li><a href="#NSS Module Names">NSS Module Names</a>:             Construction of the interface function of
                                 the NSS modules. 
-<li><a href="#NSS%20Modules%20Interface">NSS Modules Interface</a>:        Programming interface in the NSS module
+<li><a href="#NSS Modules Interface">NSS Modules Interface</a>:        Programming interface in the NSS module
                                 functions.
 
 <p>Extending NSS
 
-</p><li><a href="#Adding%20another%20Service%20to%20NSS">Adding another Service to NSS</a>:   What is to do to add a new service. 
-<li><a href="#NSS%20Module%20Function%20Internals">NSS Module Function Internals</a>:   Guidelines for writing new NSS
+</p><li><a href="#Adding another Service to NSS">Adding another Service to NSS</a>:   What is to do to add a new service. 
+<li><a href="#NSS Module Function Internals">NSS Module Function Internals</a>:   Guidelines for writing new NSS
                                         service functions.
 
 <p>Users and Groups
 
-</p><li><a href="#User%20and%20Group%20IDs">User and Group IDs</a>:           Each user has a unique numeric ID;
+</p><li><a href="#User and Group IDs">User and Group IDs</a>:           Each user has a unique numeric ID;
 				 likewise for groups. 
-<li><a href="#Process%20Persona">Process Persona</a>:              The user IDs and group IDs of a process. 
-<li><a href="#Why%20Change%20Persona">Why Change Persona</a>:           Why a program might need to change
+<li><a href="#Process Persona">Process Persona</a>:              The user IDs and group IDs of a process. 
+<li><a href="#Why Change Persona">Why Change Persona</a>:           Why a program might need to change
 				 its user and/or group IDs. 
-<li><a href="#How%20Change%20Persona">How Change Persona</a>:           Changing the user and group IDs. 
-<li><a href="#Reading%20Persona">Reading Persona</a>:              How to examine the user and group IDs.
+<li><a href="#How Change Persona">How Change Persona</a>:           Changing the user and group IDs. 
+<li><a href="#Reading Persona">Reading Persona</a>:              How to examine the user and group IDs.
 
 <p>
-</p><li><a href="#Setting%20User%20ID">Setting User ID</a>:              Functions for setting the user ID. 
-<li><a href="#Setting%20Groups">Setting Groups</a>:               Functions for setting the group IDs.
+</p><li><a href="#Setting User ID">Setting User ID</a>:              Functions for setting the user ID. 
+<li><a href="#Setting Groups">Setting Groups</a>:               Functions for setting the group IDs.
 
 <p>
-</p><li><a href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>:        Turning setuid access on and off. 
-<li><a href="#Setuid%20Program%20Example">Setuid Program Example</a>:       The pertinent parts of one sample program. 
-<li><a href="#Tips%20for%20Setuid">Tips for Setuid</a>:              How to avoid granting unlimited access.
+</p><li><a href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>:        Turning setuid access on and off. 
+<li><a href="#Setuid Program Example">Setuid Program Example</a>:       The pertinent parts of one sample program. 
+<li><a href="#Tips for Setuid">Tips for Setuid</a>:              How to avoid granting unlimited access.
 
 <p>
-</p><li><a href="#Who%20Logged%20In">Who Logged In</a>:                Getting the name of the user who logged in,
+</p><li><a href="#Who Logged In">Who Logged In</a>:                Getting the name of the user who logged in,
 				 or of the real user ID of the current process.
 
 <p>
-</p><li><a href="#User%20Accounting%20Database">User Accounting Database</a>:     Keeping information about users and various
+</p><li><a href="#User Accounting Database">User Accounting Database</a>:     Keeping information about users and various
                                  actions in databases.
 
 <p>
-</p><li><a href="#User%20Database">User Database</a>:                Functions and data structures for
+</p><li><a href="#User Database">User Database</a>:                Functions and data structures for
                         	 accessing the user database. 
-<li><a href="#Group%20Database">Group Database</a>:               Functions and data structures for
+<li><a href="#Group Database">Group Database</a>:               Functions and data structures for
                         	 accessing the group database. 
-<li><a href="#Database%20Example">Database Example</a>:             Example program showing the use of database
+<li><a href="#Database Example">Database Example</a>:             Example program showing the use of database
 				 inquiry functions. 
-<li><a href="#Netgroup%20Database">Netgroup Database</a>:            Functions for accessing the netgroup database.
+<li><a href="#Netgroup Database">Netgroup Database</a>:            Functions for accessing the netgroup database.
 
 <p>User Accounting Database
 
-</p><li><a href="#Manipulating%20the%20Database">Manipulating the Database</a>:    Scanning and modifying the user
+</p><li><a href="#Manipulating the Database">Manipulating the Database</a>:    Scanning and modifying the user
                                  accounting database. 
-<li><a href="#XPG%20Functions">XPG Functions</a>:                A standardized way for doing the same thing. 
-<li><a href="#Logging%20In%20and%20Out">Logging In and Out</a>:           Functions from BSD that modify the user
+<li><a href="#XPG Functions">XPG Functions</a>:                A standardized way for doing the same thing. 
+<li><a href="#Logging In and Out">Logging In and Out</a>:           Functions from BSD that modify the user
                                  accounting database.
 
 <p>User Database
 
-</p><li><a href="#User%20Data%20Structure">User Data Structure</a>:          What each user record contains. 
-<li><a href="#Lookup%20User">Lookup User</a>:                  How to look for a particular user. 
-<li><a href="#Scanning%20All%20Users">Scanning All Users</a>:           Scanning the list of all users, one by one. 
-<li><a href="#Writing%20a%20User%20Entry">Writing a User Entry</a>:         How a program can rewrite a user's record.
+</p><li><a href="#User Data Structure">User Data Structure</a>:          What each user record contains. 
+<li><a href="#Lookup User">Lookup User</a>:                  How to look for a particular user. 
+<li><a href="#Scanning All Users">Scanning All Users</a>:           Scanning the list of all users, one by one. 
+<li><a href="#Writing a User Entry">Writing a User Entry</a>:         How a program can rewrite a user's record.
 
 <p>Group Database
 
-</p><li><a href="#Group%20Data%20Structure">Group Data Structure</a>:         What each group record contains. 
-<li><a href="#Lookup%20Group">Lookup Group</a>:                 How to look for a particular group. 
-<li><a href="#Scanning%20All%20Groups">Scanning All Groups</a>:          Scanning the list of all groups.
+</p><li><a href="#Group Data Structure">Group Data Structure</a>:         What each group record contains. 
+<li><a href="#Lookup Group">Lookup Group</a>:                 How to look for a particular group. 
+<li><a href="#Scanning All Groups">Scanning All Groups</a>:          Scanning the list of all groups.
 
 <p>Netgroup Database
 
-</p><li><a href="#Netgroup%20Data">Netgroup Data</a>:                   Data in the Netgroup database and where
+</p><li><a href="#Netgroup Data">Netgroup Data</a>:                   Data in the Netgroup database and where
                                    it comes from. 
-<li><a href="#Lookup%20Netgroup">Lookup Netgroup</a>:                 How to look for a particular netgroup. 
-<li><a href="#Netgroup%20Membership">Netgroup Membership</a>:             How to test for netgroup membership.
+<li><a href="#Lookup Netgroup">Lookup Netgroup</a>:                 How to look for a particular netgroup. 
+<li><a href="#Netgroup Membership">Netgroup Membership</a>:             How to test for netgroup membership.
 
 <p>System Management
 
-</p><li><a href="#Host%20Identification">Host Identification</a>:          Determining the name of the machine. 
-<li><a href="#Platform%20Type">Platform Type</a>:                Determining operating system and basic
+</p><li><a href="#Host Identification">Host Identification</a>:          Determining the name of the machine. 
+<li><a href="#Platform Type">Platform Type</a>:                Determining operating system and basic
                                   machine type
-<li><a href="#Filesystem%20Handling">Filesystem Handling</a>:          Controlling/querying mounts
-<li><a href="#System%20Parameters">System Parameters</a>:            Getting and setting various system parameters
+<li><a href="#Filesystem Handling">Filesystem Handling</a>:          Controlling/querying mounts
+<li><a href="#System Parameters">System Parameters</a>:            Getting and setting various system parameters
 
 <p>Filesystem Handling
 
-</p><li><a href="#Mount%20Information">Mount Information</a>:            What is or could be mounted? 
+</p><li><a href="#Mount Information">Mount Information</a>:            What is or could be mounted? 
 <li><a href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>:        Controlling what is mounted and how
 
 <p>Mount Information
 
 </p><li><a href="#fstab">fstab</a>:                        The <code>fstab</code> file
 <li><a href="#mtab">mtab</a>:                         The <code>mtab</code> file
-<li><a href="#Other%20Mount%20Information">Other Mount Information</a>:      Other (non-libc) sources of mount information
+<li><a href="#Other Mount Information">Other Mount Information</a>:      Other (non-libc) sources of mount information
 
 <p>System Configuration
 
-</p><li><a href="#General%20Limits">General Limits</a>:            Constants and functions that describe
+</p><li><a href="#General Limits">General Limits</a>:            Constants and functions that describe
 				various process-related limits that have
 				one uniform value for any given machine. 
-<li><a href="#System%20Options">System Options</a>:            Optional POSIX features. 
-<li><a href="#Version%20Supported">Version Supported</a>:         Version numbers of POSIX.1 and POSIX.2. 
+<li><a href="#System Options">System Options</a>:            Optional POSIX features. 
+<li><a href="#Version Supported">Version Supported</a>:         Version numbers of POSIX.1 and POSIX.2. 
 <li><a href="#Sysconf">Sysconf</a>:                   Getting specific configuration values
                                 of general limits and system options. 
 <li><a href="#Minimums">Minimums</a>:                  Minimum values for general limits.
 
 <p>
-</p><li><a href="#Limits%20for%20Files">Limits for Files</a>:          Size limitations that pertain to individual files. 
+</p><li><a href="#Limits for Files">Limits for Files</a>:          Size limitations that pertain to individual files. 
                                 These can vary between file systems
                                 or even from file to file. 
-<li><a href="#Options%20for%20Files">Options for Files</a>:         Optional features that some files may support. 
-<li><a href="#File%20Minimums">File Minimums</a>:             Minimum values for file limits. 
+<li><a href="#Options for Files">Options for Files</a>:         Optional features that some files may support. 
+<li><a href="#File Minimums">File Minimums</a>:             Minimum values for file limits. 
 <li><a href="#Pathconf">Pathconf</a>:                  Getting the limit values for a particular file.
 
 <p>
-</p><li><a href="#Utility%20Limits">Utility Limits</a>:            Capacity limits of some POSIX.2 utility programs. 
-<li><a href="#Utility%20Minimums">Utility Minimums</a>:          Minimum allowable values of those limits.
+</p><li><a href="#Utility Limits">Utility Limits</a>:            Capacity limits of some POSIX.2 utility programs. 
+<li><a href="#Utility Minimums">Utility Minimums</a>:          Minimum allowable values of those limits.
 
 <p>
-</p><li><a href="#String%20Parameters">String Parameters</a>:         Getting the default search path.
+</p><li><a href="#String Parameters">String Parameters</a>:         Getting the default search path.
 
 <p>Sysconf
 
-</p><li><a href="#Sysconf%20Definition">Sysconf Definition</a>:         Detailed specifications of <code>sysconf</code>. 
-<li><a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>:      The list of parameters <code>sysconf</code> can read. 
-<li><a href="#Examples%20of%20Sysconf">Examples of Sysconf</a>:        How to use <code>sysconf</code> and the parameter
+</p><li><a href="#Sysconf Definition">Sysconf Definition</a>:         Detailed specifications of <code>sysconf</code>. 
+<li><a href="#Constants for Sysconf">Constants for Sysconf</a>:      The list of parameters <code>sysconf</code> can read. 
+<li><a href="#Examples of Sysconf">Examples of Sysconf</a>:        How to use <code>sysconf</code> and the parameter
 				 macros properly together.
 
 <p>Cryptographic Functions
 
-</p><li><a href="#Legal%20Problems">Legal Problems</a>:               This software can get you locked up, or worse. 
+</p><li><a href="#Legal Problems">Legal Problems</a>:               This software can get you locked up, or worse. 
 <li><a href="#getpass">getpass</a>:                      Prompting the user for a password. 
 <li><a href="#crypt">crypt</a>:                        A one-way function for UNIX passwords. 
-<li><a href="#DES%20Encryption">DES Encryption</a>:               Routines for DES encryption.
+<li><a href="#DES Encryption">DES Encryption</a>:               Routines for DES encryption.
 
 <p>Debugging Support
 
 </p><li><a href="#Backtraces">Backtraces</a>:                 Obtaining and printing a back trace of the
                                current stack.
 
 <p>Language Features
 
-</p><li><a href="#Consistency%20Checking">Consistency Checking</a>:         Using <code>assert</code> to abort if
-				 something ``impossible'' happens. 
-<li><a href="#Variadic%20Functions">Variadic Functions</a>:           Defining functions with varying numbers
+</p><li><a href="#Consistency Checking">Consistency Checking</a>:         Using <code>assert</code> to abort if
+				 something "impossible" happens. 
+<li><a href="#Variadic Functions">Variadic Functions</a>:           Defining functions with varying numbers
                                  of args. 
-<li><a href="#Null%20Pointer%20Constant">Null Pointer Constant</a>:        The macro <code>NULL</code>. 
-<li><a href="#Important%20Data%20Types">Important Data Types</a>:         Data types for object sizes. 
-<li><a href="#Data%20Type%20Measurements">Data Type Measurements</a>:       Parameters of data type representations.
+<li><a href="#Null Pointer Constant">Null Pointer Constant</a>:        The macro <code>NULL</code>. 
+<li><a href="#Important Data Types">Important Data Types</a>:         Data types for object sizes. 
+<li><a href="#Data Type Measurements">Data Type Measurements</a>:       Parameters of data type representations.
 
 <p>Variadic Functions
 
-</p><li><a href="#Why%20Variadic">Why Variadic</a>:                 Reasons for making functions take
+</p><li><a href="#Why Variadic">Why Variadic</a>:                 Reasons for making functions take
                                  variable arguments. 
-<li><a href="#How%20Variadic">How Variadic</a>:                 How to define and call variadic functions. 
-<li><a href="#Variadic%20Example">Variadic Example</a>:             A complete example.
+<li><a href="#How Variadic">How Variadic</a>:                 How to define and call variadic functions. 
+<li><a href="#Variadic Example">Variadic Example</a>:             A complete example.
 
 <p>How Variadic
 
-</p><li><a href="#Variadic%20Prototypes">Variadic Prototypes</a>:   How to make a prototype for a function
+</p><li><a href="#Variadic Prototypes">Variadic Prototypes</a>:   How to make a prototype for a function
 			  with variable arguments. 
-<li><a href="#Receiving%20Arguments">Receiving Arguments</a>:   Steps you must follow to access the
+<li><a href="#Receiving Arguments">Receiving Arguments</a>:   Steps you must follow to access the
 			  optional argument values. 
-<li><a href="#How%20Many%20Arguments">How Many Arguments</a>:    How to decide whether there are more arguments. 
-<li><a href="#Calling%20Variadics">Calling Variadics</a>:     Things you need to know about calling
+<li><a href="#How Many Arguments">How Many Arguments</a>:    How to decide whether there are more arguments. 
+<li><a href="#Calling Variadics">Calling Variadics</a>:     Things you need to know about calling
 			  variable arguments functions. 
-<li><a href="#Argument%20Macros">Argument Macros</a>:       Detailed specification of the macros
+<li><a href="#Argument Macros">Argument Macros</a>:       Detailed specification of the macros
         		  for accessing variable arguments. 
-<li><a href="#Old%20Varargs">Old Varargs</a>: 		 The pre-ISO way of defining variadic functions.
+<li><a href="#Old Varargs">Old Varargs</a>: 		 The pre-ISO way of defining variadic functions.
 
 <p>Data Type Measurements
 
-</p><li><a href="#Width%20of%20Type">Width of Type</a>:            How many bits does an integer type hold? 
-<li><a href="#Range%20of%20Type">Range of Type</a>:            What are the largest and smallest values
+</p><li><a href="#Width of Type">Width of Type</a>:            How many bits does an integer type hold? 
+<li><a href="#Range of Type">Range of Type</a>:            What are the largest and smallest values
 			     that an integer type can hold? 
-<li><a href="#Floating%20Type%20Macros">Floating Type Macros</a>:     Parameters that measure the floating point types. 
-<li><a href="#Structure%20Measurement">Structure Measurement</a>:    Getting measurements on structure types.
+<li><a href="#Floating Type Macros">Floating Type Macros</a>:     Parameters that measure the floating point types. 
+<li><a href="#Structure Measurement">Structure Measurement</a>:    Getting measurements on structure types.
 
 <p>Floating Type Macros
 
-</p><li><a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>:      Definitions of terminology. 
-<li><a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>:    Details of specific macros. 
-<li><a href="#IEEE%20Floating%20Point">IEEE Floating Point</a>:          The measurements for one common
+</p><li><a href="#Floating Point Concepts">Floating Point Concepts</a>:      Definitions of terminology. 
+<li><a href="#Floating Point Parameters">Floating Point Parameters</a>:    Details of specific macros. 
+<li><a href="#IEEE Floating Point">IEEE Floating Point</a>:          The measurements for one common
                                  representation.
 
 <p>Installation
 
-</p><li><a href="#Configuring%20and%20compiling">Configuring and compiling</a>:    How to compile and test GNU libc. 
-<li><a href="#Running%20make%20install">Running make install</a>:         How to install it once you've got it compiled. 
-<li><a href="#Tools%20for%20Compilation">Tools for Compilation</a>:        You'll need these first. 
-<li><a href="#Supported%20Configurations">Supported Configurations</a>:     What it runs on, what it doesn't. 
+</p><li><a href="#Configuring and compiling">Configuring and compiling</a>:    How to compile and test GNU libc. 
+<li><a href="#Running make install">Running make install</a>:         How to install it once you've got it compiled. 
+<li><a href="#Tools for Compilation">Tools for Compilation</a>:        You'll need these first. 
+<li><a href="#Supported Configurations">Supported Configurations</a>:     What it runs on, what it doesn't. 
 <li><a href="#Linux">Linux</a>:                        Specific advice for Linux systems. 
-<li><a href="#Reporting%20Bugs">Reporting Bugs</a>:               So they'll get fixed.
+<li><a href="#Reporting Bugs">Reporting Bugs</a>:               So they'll get fixed.
 
 <p>Maintenance
 
-</p><li><a href="#Source%20Layout">Source Layout</a>:          How to add new functions or header files
+</p><li><a href="#Source Layout">Source Layout</a>:          How to add new functions or header files
                              to the GNU C library. 
 <li><a href="#Porting">Porting</a>:                How to port the GNU C library to
                              a new machine or operating system.
 
 <p>Porting
 
-</p><li><a href="#Hierarchy%20Conventions">Hierarchy Conventions</a>:        The layout of the <code>sysdeps</code> hierarchy. 
-<li><a href="#Porting%20to%20Unix">Porting to Unix</a>:              Porting the library to an average
+</p><li><a href="#Hierarchy Conventions">Hierarchy Conventions</a>:        The layout of the <code>sysdeps</code> hierarchy. 
+<li><a href="#Porting to Unix">Porting to Unix</a>:              Porting the library to an average
                                    Unix-like system. 
 </ul>
 
 <p><hr>
 Node:<a name="Introduction">Introduction</a>,
-Next:<a rel=next accesskey=n href="#Error%20Reporting">Error Reporting</a>,
+Next:<a rel=next accesskey=n href="#Error Reporting">Error Reporting</a>,
 Previous:<a rel=previous accesskey=p href="#Top">Top</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -1337,28 +1337,28 @@
 to other systems.  But the emphasis in this manual is not on strict
 portability.
 
 <ul>
-<li><a accesskey=1 href="#Getting%20Started">Getting Started</a>:              What this manual is for and how to use it. 
-<li><a accesskey=2 href="#Standards%20and%20Portability">Standards and Portability</a>:    Standards and sources upon which the GNU
+<li><a accesskey=1 href="#Getting Started">Getting Started</a>:              What this manual is for and how to use it. 
+<li><a accesskey=2 href="#Standards and Portability">Standards and Portability</a>:    Standards and sources upon which the GNU
                                  C library is based. 
-<li><a accesskey=3 href="#Using%20the%20Library">Using the Library</a>:            Some practical uses for the library. 
-<li><a accesskey=4 href="#Roadmap%20to%20the%20Manual">Roadmap to the Manual</a>:        Overview of the remaining chapters in
+<li><a accesskey=3 href="#Using the Library">Using the Library</a>:            Some practical uses for the library. 
+<li><a accesskey=4 href="#Roadmap to the Manual">Roadmap to the Manual</a>:        Overview of the remaining chapters in
                                  this manual. 
 </ul>
 
 <p><hr>
-Node:<a name="Getting%20Started">Getting Started</a>,
-Next:<a rel=next accesskey=n href="#Standards%20and%20Portability">Standards and Portability</a>,
+Node:<a name="Getting Started">Getting Started</a>,
+Next:<a rel=next accesskey=n href="#Standards and Portability">Standards and Portability</a>,
 Up:<a rel=up accesskey=u href="#Introduction">Introduction</a>
 <br>
 
 <h3>Getting Started</h3>
 
 <p>This manual is written with the assumption that you are at least
 somewhat familiar with the C programming language and basic programming
 concepts.  Specifically, familiarity with ISO standard C
-(see <a href="#ISO%20C">ISO C</a>), rather than "traditional" pre-ISO C dialects, is
+(see <a href="#ISO C">ISO C</a>), rather than "traditional" pre-ISO C dialects, is
 assumed.
 
 <p>The GNU C library includes several <dfn>header files</dfn>, each of which
 provides definitions and declarations for a group of related facilities;
@@ -1378,11 +1378,11 @@
 library functions, and <em>where</em> in this manual you can find more
 specific information about them.
 
 <p><hr>
-Node:<a name="Standards%20and%20Portability">Standards and Portability</a>,
-Next:<a rel=next accesskey=n href="#Using%20the%20Library">Using the Library</a>,
-Previous:<a rel=previous accesskey=p href="#Getting%20Started">Getting Started</a>,
+Node:<a name="Standards and Portability">Standards and Portability</a>,
+Next:<a rel=next accesskey=n href="#Using the Library">Using the Library</a>,
+Previous:<a rel=previous accesskey=p href="#Getting Started">Getting Started</a>,
 Up:<a rel=up accesskey=u href="#Introduction">Introduction</a>
 <br>
 
 <h3>Standards and Portability</h3>
@@ -1398,26 +1398,26 @@
 library.  This section gives you an overview of these standards, so that
 you will know what they are when they are mentioned in other parts of
 the manual.
 
-<p>See <a href="#Library%20Summary">Library Summary</a>, for an alphabetical list of the functions and
+<p>See <a href="#Library Summary">Library Summary</a>, for an alphabetical list of the functions and
 other symbols provided by the library.  This list also states which
 standards each function or symbol comes from.
 
 <ul>
-<li><a accesskey=1 href="#ISO%20C">ISO C</a>:                        The international standard for the C
+<li><a accesskey=1 href="#ISO C">ISO C</a>:                        The international standard for the C
                                  programming language. 
 <li><a accesskey=2 href="#POSIX">POSIX</a>:                        The ISO/IEC 9945 (aka IEEE 1003) standards
                                  for operating systems. 
-<li><a accesskey=3 href="#Berkeley%20Unix">Berkeley Unix</a>:                BSD and SunOS. 
+<li><a accesskey=3 href="#Berkeley Unix">Berkeley Unix</a>:                BSD and SunOS. 
 <li><a accesskey=4 href="#SVID">SVID</a>:                         The System V Interface Description. 
 <li><a accesskey=5 href="#XPG">XPG</a>:                          The X/Open Portability Guide. 
 </ul>
 
 <p><hr>
-Node:<a name="ISO%20C">ISO C</a>,
+Node:<a name="ISO C">ISO C</a>,
 Next:<a rel=next accesskey=n href="#POSIX">POSIX</a>,
-Up:<a rel=up accesskey=u href="#Standards%20and%20Portability">Standards and Portability</a>
+Up:<a rel=up accesskey=u href="#Standards and Portability">Standards and Portability</a>
 <br>
 
 <h4>ISO C</h4>
 
@@ -1434,15 +1434,15 @@
 <p>If you are concerned about strict adherence to the ISO&nbsp;C standard, you
 should use the <code>-ansi</code> option when you compile your programs with
 the GNU C compiler.  This tells the compiler to define <em>only</em> ISO
 standard features from the library header files, unless you explicitly
-ask for additional features.  See <a href="#Feature%20Test%20Macros">Feature Test Macros</a>, for
+ask for additional features.  See <a href="#Feature Test Macros">Feature Test Macros</a>, for
 information on how to do this.
 
 <p>Being able to restrict the library to include only ISO&nbsp;C features is
 important because ISO&nbsp;C puts limitations on what names can be defined
 by the library implementation, and the GNU extensions don't fit these
-limitations.  See <a href="#Reserved%20Names">Reserved Names</a>, for more information about these
+limitations.  See <a href="#Reserved Names">Reserved Names</a>, for more information about these
 restrictions.
 
 <p>This manual does not attempt to give you complete details on the
 differences between ISO&nbsp;C and older dialects.  It gives advice on how
@@ -1450,11 +1450,11 @@
 not aim for completeness.
 
 <p><hr>
 Node:<a name="POSIX">POSIX</a>,
-Next:<a rel=next accesskey=n href="#Berkeley%20Unix">Berkeley Unix</a>,
-Previous:<a rel=previous accesskey=p href="#ISO%20C">ISO C</a>,
-Up:<a rel=up accesskey=u href="#Standards%20and%20Portability">Standards and Portability</a>
+Next:<a rel=next accesskey=n href="#Berkeley Unix">Berkeley Unix</a>,
+Previous:<a rel=previous accesskey=p href="#ISO C">ISO C</a>,
+Up:<a rel=up accesskey=u href="#Standards and Portability">Standards and Portability</a>
 <br>
 
 <h4>POSIX (The Portable Operating System Interface)</h4>
 
@@ -1476,22 +1476,22 @@
 <p>The GNU C library implements all of the functions specified in
 <cite>ISO/IEC 9945-1:1996, the POSIX System Application Program
 Interface</cite>, commonly referred to as POSIX.1.  The primary extensions to
 the ISO&nbsp;C facilities specified by this standard include file system
-interface primitives (see <a href="#File%20System%20Interface">File System Interface</a>), device-specific
-terminal control functions (see <a href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>), and
+interface primitives (see <a href="#File System Interface">File System Interface</a>), device-specific
+terminal control functions (see <a href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>), and
 process control functions (see <a href="#Processes">Processes</a>).
 
 <p>Some facilities from <cite>ISO/IEC 9945-2:1993, the POSIX Shell and
 Utilities standard</cite> (POSIX.2) are also implemented in the GNU library. 
 These include utilities for dealing with regular expressions and other
-pattern matching facilities (see <a href="#Pattern%20Matching">Pattern Matching</a>).
+pattern matching facilities (see <a href="#Pattern Matching">Pattern Matching</a>).
 
 <p><hr>
-Node:<a name="Berkeley%20Unix">Berkeley Unix</a>,
+Node:<a name="Berkeley Unix">Berkeley Unix</a>,
 Next:<a rel=next accesskey=n href="#SVID">SVID</a>,
 Previous:<a rel=previous accesskey=p href="#POSIX">POSIX</a>,
-Up:<a rel=up accesskey=u href="#Standards%20and%20Portability">Standards and Portability</a>
+Up:<a rel=up accesskey=u href="#Standards and Portability">Standards and Portability</a>
 <br>
 
 <h4>Berkeley Unix</h4>
 
@@ -1501,17 +1501,17 @@
 <dfn>SunOS</dfn> (a popular 4.2 BSD derivative that includes some Unix System
 V functionality).  These systems support most of the ISO&nbsp;C and POSIX
 facilities, and 4.4 BSD and newer releases of SunOS in fact support them all.
 
-<p>The BSD facilities include symbolic links (see <a href="#Symbolic%20Links">Symbolic Links</a>), the
-<code>select</code> function (see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>), the BSD signal
-functions (see <a href="#BSD%20Signal%20Handling">BSD Signal Handling</a>), and sockets (see <a href="#Sockets">Sockets</a>).
+<p>The BSD facilities include symbolic links (see <a href="#Symbolic Links">Symbolic Links</a>), the
+<code>select</code> function (see <a href="#Waiting for I%2fO">Waiting for I/O</a>), the BSD signal
+functions (see <a href="#BSD Signal Handling">BSD Signal Handling</a>), and sockets (see <a href="#Sockets">Sockets</a>).
 
 <p><hr>
 Node:<a name="SVID">SVID</a>,
 Next:<a rel=next accesskey=n href="#XPG">XPG</a>,
-Previous:<a rel=previous accesskey=p href="#Berkeley%20Unix">Berkeley Unix</a>,
-Up:<a rel=up accesskey=u href="#Standards%20and%20Portability">Standards and Portability</a>
+Previous:<a rel=previous accesskey=p href="#Berkeley Unix">Berkeley Unix</a>,
+Up:<a rel=up accesskey=u href="#Standards and Portability">Standards and Portability</a>
 <br>
 
 <h4>SVID (The System V Interface Description)</h4>
 
@@ -1533,9 +1533,9 @@
 
 <p><hr>
 Node:<a name="XPG">XPG</a>,
 Previous:<a rel=previous accesskey=p href="#SVID">SVID</a>,
-Up:<a rel=up accesskey=u href="#Standards%20and%20Portability">Standards and Portability</a>
+Up:<a rel=up accesskey=u href="#Standards and Portability">Standards and Portability</a>
 <br>
 
 <h4>XPG (The X/Open Portability Guide)</h4>
 
@@ -1555,11 +1555,11 @@
 precondition for getting the Unix brand chances are good that the
 functionality is available on commercial systems.
 
 <p><hr>
-Node:<a name="Using%20the%20Library">Using the Library</a>,
-Next:<a rel=next accesskey=n href="#Roadmap%20to%20the%20Manual">Roadmap to the Manual</a>,
-Previous:<a rel=previous accesskey=p href="#Standards%20and%20Portability">Standards and Portability</a>,
+Node:<a name="Using the Library">Using the Library</a>,
+Next:<a rel=next accesskey=n href="#Roadmap to the Manual">Roadmap to the Manual</a>,
+Previous:<a rel=previous accesskey=p href="#Standards and Portability">Standards and Portability</a>,
 Up:<a rel=up accesskey=u href="#Introduction">Introduction</a>
 <br>
 
 <h3>Using the Library</h3>
@@ -1567,21 +1567,21 @@
 <p>This section describes some of the practical issues involved in using
 the GNU C library.
 
 <ul>
-<li><a accesskey=1 href="#Header%20Files">Header Files</a>:                 How to include the header files in your
+<li><a accesskey=1 href="#Header Files">Header Files</a>:                 How to include the header files in your
                                  programs. 
-<li><a accesskey=2 href="#Macro%20Definitions">Macro Definitions</a>:            Some functions in the library may really
+<li><a accesskey=2 href="#Macro Definitions">Macro Definitions</a>:            Some functions in the library may really
                                  be implemented as macros. 
-<li><a accesskey=3 href="#Reserved%20Names">Reserved Names</a>:               The C standard reserves some names for
+<li><a accesskey=3 href="#Reserved Names">Reserved Names</a>:               The C standard reserves some names for
                                  the library, and some for users. 
-<li><a accesskey=4 href="#Feature%20Test%20Macros">Feature Test Macros</a>:          How to control what names are defined. 
+<li><a accesskey=4 href="#Feature Test Macros">Feature Test Macros</a>:          How to control what names are defined. 
 </ul>
 
 <p><hr>
-Node:<a name="Header%20Files">Header Files</a>,
-Next:<a rel=next accesskey=n href="#Macro%20Definitions">Macro Definitions</a>,
-Up:<a rel=up accesskey=u href="#Using%20the%20Library">Using the Library</a>
+Node:<a name="Header Files">Header Files</a>,
+Next:<a rel=next accesskey=n href="#Macro Definitions">Macro Definitions</a>,
+Up:<a rel=up accesskey=u href="#Using the Library">Using the Library</a>
 <br>
 
 <h4>Header Files</h4>
 
@@ -1628,12 +1628,12 @@
 <p>Typically, <code>#include</code> directives are placed at the top of the C
 source file, before any other code.  If you begin your source files with
 some comments explaining what the code in the file does (a good idea),
 put the <code>#include</code> directives immediately afterwards, following the
-feature test macro definition (see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>).
+feature test macro definition (see <a href="#Feature Test Macros">Feature Test Macros</a>).
 
 <p>For more information about the use of header files and <code>#include</code>
-directives, see <a href="cpp.info.html#Header%20Files">Header Files</a>.
+directives, see <a href="cpp.info.html#Header Files">Header Files</a>.
 
 <p>The GNU C library provides several header files, each of which contains
 the type and macro definitions and variable and function declarations
 for a group of related facilities.  This means that your programs may
@@ -1663,12 +1663,12 @@
 more efficient macro replacements for some functions.  It is also a sure
 way to have the correct declaration.
 
 <p><hr>
-Node:<a name="Macro%20Definitions">Macro Definitions</a>,
-Next:<a rel=next accesskey=n href="#Reserved%20Names">Reserved Names</a>,
-Previous:<a rel=previous accesskey=p href="#Header%20Files">Header Files</a>,
-Up:<a rel=up accesskey=u href="#Using%20the%20Library">Using the Library</a>
+Node:<a name="Macro Definitions">Macro Definitions</a>,
+Next:<a rel=next accesskey=n href="#Reserved Names">Reserved Names</a>,
+Previous:<a rel=previous accesskey=p href="#Header Files">Header Files</a>,
+Up:<a rel=up accesskey=u href="#Using the Library">Using the Library</a>
 <br>
 
 <h4>Macro Definitions of Functions</h4>
 
@@ -1729,12 +1729,12 @@
 need for any of these methods.  In fact, removing macro definitions usually
 just makes your program slower.
 
 <p><hr>
-Node:<a name="Reserved%20Names">Reserved Names</a>,
-Next:<a rel=next accesskey=n href="#Feature%20Test%20Macros">Feature Test Macros</a>,
-Previous:<a rel=previous accesskey=p href="#Macro%20Definitions">Macro Definitions</a>,
-Up:<a rel=up accesskey=u href="#Using%20the%20Library">Using the Library</a>
+Node:<a name="Reserved Names">Reserved Names</a>,
+Next:<a rel=next accesskey=n href="#Feature Test Macros">Feature Test Macros</a>,
+Previous:<a rel=previous accesskey=p href="#Macro Definitions">Macro Definitions</a>,
+Up:<a rel=up accesskey=u href="#Using the Library">Using the Library</a>
 <br>
 
 <h4>Reserved Names</h4>
 
@@ -1758,10 +1758,10 @@
 
 <li>It allows the compiler to do whatever special optimizations it pleases
 on calls to these functions, without the possibility that they may have
 been redefined by the user.  Some library facilities, such as those for
-dealing with variadic arguments (see <a href="#Variadic%20Functions">Variadic Functions</a>)
-and non-local exits (see <a href="#Non-Local%20Exits">Non-Local Exits</a>), actually require a
+dealing with variadic arguments (see <a href="#Variadic Functions">Variadic Functions</a>)
+and non-local exits (see <a href="#Non-Local Exits">Non-Local Exits</a>), actually require a
 considerable amount of cooperation on the part of the C compiler, and
 with respect to the implementation, it might be easier for the compiler
 to treat these as built-in parts of the language. 
 </ul>
@@ -1781,13 +1781,13 @@
 or POSIX standards, so you should avoid these names.
 
 <ul>
 <li>Names beginning with a capital <code>E</code> followed a digit or uppercase
-letter may be used for additional error code names.  See <a href="#Error%20Reporting">Error Reporting</a>.
+letter may be used for additional error code names.  See <a href="#Error Reporting">Error Reporting</a>.
 
 <li>Names that begin with either <code>is</code> or <code>to</code> followed by a
 lowercase letter may be used for additional character testing and
-conversion functions.  See <a href="#Character%20Handling">Character Handling</a>.
+conversion functions.  See <a href="#Character Handling">Character Handling</a>.
 
 <li>Names that begin with <code>LC_</code> followed by an uppercase letter may be
 used for additional macros specifying locale attributes. 
 See <a href="#Locales">Locales</a>.
@@ -1797,16 +1797,16 @@
 functions that operate on <code>float</code> and <code>long double</code> arguments,
 respectively.
 
 <li>Names that begin with <code>SIG</code> followed by an uppercase letter are
-reserved for additional signal names.  See <a href="#Standard%20Signals">Standard Signals</a>.
+reserved for additional signal names.  See <a href="#Standard Signals">Standard Signals</a>.
 
 <li>Names that begin with <code>SIG_</code> followed by an uppercase letter are
-reserved for additional signal actions.  See <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>.
+reserved for additional signal actions.  See <a href="#Basic Signal Handling">Basic Signal Handling</a>.
 
 <li>Names beginning with <code>str</code>, <code>mem</code>, or <code>wcs</code> followed by a
 lowercase letter are reserved for additional string and array functions. 
-See <a href="#String%20and%20Array%20Utilities">String and Array Utilities</a>.
+See <a href="#String and Array Utilities">String and Array Utilities</a>.
 
 <li>Names that end with <code>_t</code> are reserved for additional type names. 
 </ul>
 
@@ -1840,11 +1840,11 @@
 <code>B</code> followed by a digit. 
 </ul>
 
 <p><hr>
-Node:<a name="Feature%20Test%20Macros">Feature Test Macros</a>,
-Previous:<a rel=previous accesskey=p href="#Reserved%20Names">Reserved Names</a>,
-Up:<a rel=up accesskey=u href="#Using%20the%20Library">Using the Library</a>
+Node:<a name="Feature Test Macros">Feature Test Macros</a>,
+Previous:<a rel=previous accesskey=p href="#Reserved Names">Reserved Names</a>,
+Up:<a rel=up accesskey=u href="#Using the Library">Using the Library</a>
 <br>
 
 <h4>Feature Test Macros</h4>
 
@@ -1853,9 +1853,9 @@
 
 <p>If you compile your programs using <code>gcc -ansi</code>, you get only the
 ISO&nbsp;C library features, unless you explicitly request additional
 features by defining one or more of the feature macros. 
-See <a href="gcc.info.html#Invoking%20GCC">GNU CC Command Options</a>,
+See <a href="gcc.info.html#Invoking GCC">GNU CC Command Options</a>,
 for more information about GCC options.
 
 <p>You should define these macros by using <code>#define</code> preprocessor
 directives at the top of your source code files.  These directives
@@ -1879,16 +1879,15 @@
 from including header files outside the standard, or relying on semantics
 undefined within the standard.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_POSIX_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_POSIX_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If you define this macro, then the functionality from the POSIX.1
 standard (IEEE Standard 1003.1) is available, as well as all of the
 ISO&nbsp;C facilities.
@@ -1898,16 +1897,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_POSIX_C_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_POSIX_C_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Define this macro to a positive integer to control which POSIX
 functionality is made available.  The greater the value of this macro,
 the more functionality is made available.
@@ -1934,16 +1932,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_BSD_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_BSD_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If you define this macro, functionality derived from 4.3 BSD Unix is
 included as well as the ISO&nbsp;C, POSIX.1, and POSIX.2 material.
 
@@ -1964,40 +1961,35 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_SVID_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_SVID_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If you define this macro, functionality derived from SVID is
 included as well as the ISO&nbsp;C, POSIX.1, POSIX.2, and X/Open material. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_XOPEN_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_XOPEN_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
-<tr><td>
-
+<table width="65%" align="center">
 <tr>
-<td align="left"><b>_XOPEN_SOURCE_EXTENDED</b><i>
-</i></td>
+<td align="left"><code><b>_XOPEN_SOURCE_EXTENDED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If you define this macro, functionality described in the X/Open
 Portability Guide is included.  This is a superset of the POSIX.1 and
 POSIX.2 functionality and in fact <code>_POSIX_SOURCE</code> and
@@ -2016,16 +2008,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_LARGEFILE_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_LARGEFILE_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this macro is defined some extra functions are available which
 rectify a few shortcomings in all previous standards.  Specifically,
 the functions <code>fseeko</code> and <code>ftello</code> are available.  Without
@@ -2037,16 +2028,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_LARGEFILE64_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_LARGEFILE64_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If you define this macro an additional set of functions is made available
 which enables 32&nbsp;bit systems to use files of sizes beyond
 the usual limit of 2GB.  This interface is not available if the system
@@ -2065,16 +2055,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_FILE_OFFSET_BITS</b><i>
-</i></td>
+<td align="left"><code><b>_FILE_OFFSET_BITS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro determines which file system interface shall be used, one
 replacing the other.  Whereas <code>_LARGEFILE64_SOURCE</code> makes the 64&nbsp;bit interface available as an additional interface,
 <code>_FILE_OFFSET_BITS</code> allows the 64&nbsp;bit interface to
@@ -2100,16 +2089,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_ISOC99_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_ISOC99_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Until the revised ISO&nbsp;C standard is widely adopted the new features
 are not automatically enabled.  The GNU libc nevertheless has a complete
 implementation of the new standard and to enable the new features the
@@ -2117,16 +2105,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_GNU_SOURCE</b><i>
-</i></td>
+<td align="left"><code><b>_GNU_SOURCE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If you define this macro, everything is included: ISO&nbsp;C89, ISO&nbsp;C99, POSIX.1, POSIX.2, BSD, SVID, X/Open, LFS, and GNU extensions.  In
 the cases where POSIX.1 conflicts with BSD, the POSIX definitions take
 precedence.
@@ -2147,22 +2134,21 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>_REENTRANT</b><i>
-</i></td>
+<td align="left"><code><b>_REENTRANT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 
 <tr>
-<td align="left"><b>_THREAD_SAFE</b><i>
-</i></td>
+<td align="left"><code><b>_THREAD_SAFE</b><i>
+</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If you define one of these macros, reentrant versions of several functions get
 declared.  Some of the functions are specified in POSIX.1c but many others
 are only available on a few other systems or are unique to GNU libc. 
@@ -2196,10 +2182,10 @@
 an effect: it causes the BSD features to take priority over the conflicting
 POSIX features.
 
 <p><hr>
-Node:<a name="Roadmap%20to%20the%20Manual">Roadmap to the Manual</a>,
-Previous:<a rel=previous accesskey=p href="#Using%20the%20Library">Using the Library</a>,
+Node:<a name="Roadmap to the Manual">Roadmap to the Manual</a>,
+Previous:<a rel=previous accesskey=p href="#Using the Library">Using the Library</a>,
 Up:<a rel=up accesskey=u href="#Introduction">Introduction</a>
 <br>
 
 <h3>Roadmap to the Manual</h3>
@@ -2207,12 +2193,12 @@
 <p>Here is an overview of the contents of the remaining chapters of
 this manual.
 
 <ul>
-<li><a href="#Error%20Reporting">Error Reporting</a>, describes how errors detected by the library
+<li><a href="#Error Reporting">Error Reporting</a>, describes how errors detected by the library
 are reported.
 
-<li><a href="#Language%20Features">Language Features</a>, contains information about library support for
+<li><a href="#Language Features">Language Features</a>, contains information about library support for
 standard parts of the C language, including things like the <code>sizeof</code>
 operator and the symbolic constant <code>NULL</code>, how to write functions
 accepting variable numbers of arguments, and constants describing the
 ranges and other properties of the numerical types.  There is also a simple
@@ -2224,35 +2210,35 @@
 memory.  If you do not know in advance how much memory your program
 needs, you can allocate it dynamically instead, and manipulate it via
 pointers.
 
-<li><a href="#Character%20Handling">Character Handling</a>, contains information about character
+<li><a href="#Character Handling">Character Handling</a>, contains information about character
 classification functions (such as <code>isspace</code>) and functions for
 performing case conversion.
 
-<li><a href="#String%20and%20Array%20Utilities">String and Array Utilities</a>, has descriptions of functions for
+<li><a href="#String and Array Utilities">String and Array Utilities</a>, has descriptions of functions for
 manipulating strings (null-terminated character arrays) and general
 byte arrays, including operations such as copying and comparison.
 
-<li><a href="#I%2fO%20Overview">I/O Overview</a>, gives an overall look at the input and output
+<li><a href="#I%2fO Overview">I/O Overview</a>, gives an overall look at the input and output
 facilities in the library, and contains information about basic concepts
 such as file names.
 
-<li><a href="#I%2fO%20on%20Streams">I/O on Streams</a>, describes I/O operations involving streams (or
+<li><a href="#I%2fO on Streams">I/O on Streams</a>, describes I/O operations involving streams (or
 <code>FILE&nbsp;*</code> objects).  These are the normal C library functions
 from <code>stdio.h</code>.
 
-<li><a href="#Low-Level%20I%2fO">Low-Level I/O</a>, contains information about I/O operations
+<li><a href="#Low-Level I%2fO">Low-Level I/O</a>, contains information about I/O operations
 on file descriptors.  File descriptors are a lower-level mechanism
 specific to the Unix family of operating systems.
 
-<li><a href="#File%20System%20Interface">File System Interface</a>, has descriptions of operations on entire
+<li><a href="#File System Interface">File System Interface</a>, has descriptions of operations on entire
 files, such as functions for deleting and renaming them and for creating
 new directories.  This chapter also contains information about how you
 can access the attributes of a file, such as its owner and file protection
 modes.
 
-<li><a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>, contains information about simple interprocess
+<li><a href="#Pipes and FIFOs">Pipes and FIFOs</a>, contains information about simple interprocess
 communication mechanisms.  Pipes allow communication between two related
 processes (such as between a parent and child), while FIFOs allow
 communication between processes sharing a common file system on the same
 machine.
@@ -2261,9 +2247,9 @@
 mechanism that allows processes running on different machines to
 communicate over a network.  This chapter also contains information about
 Internet host addressing and how to use the system network databases.
 
-<li><a href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>, describes how you can change the
+<li><a href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>, describes how you can change the
 attributes of a terminal device.  If you want to disable echo of
 characters typed by the user, for example, read this chapter.
 
 <li><a href="#Mathematics">Mathematics</a>, contains information about the math library
@@ -2274,64 +2260,64 @@
 <li><a href="#Arithmetic">Low-Level Arithmetic Functions</a>, describes functions
 for simple arithmetic, analysis of floating-point values, and reading
 numbers from strings.
 
-<li><a href="#Searching%20and%20Sorting">Searching and Sorting</a>, contains information about functions
+<li><a href="#Searching and Sorting">Searching and Sorting</a>, contains information about functions
 for searching and sorting arrays.  You can use these functions on any
 kind of array by providing an appropriate comparison function.
 
-<li><a href="#Pattern%20Matching">Pattern Matching</a>, presents functions for matching regular expressions
+<li><a href="#Pattern Matching">Pattern Matching</a>, presents functions for matching regular expressions
 and shell file name patterns, and for expanding words as the shell does.
 
-<li><a href="#Date%20and%20Time">Date and Time</a>, describes functions for measuring both calendar time
+<li><a href="#Date and Time">Date and Time</a>, describes functions for measuring both calendar time
 and CPU time, as well as functions for setting alarms and timers.
 
-<li><a href="#Character%20Set%20Handling">Character Set Handling</a>, contains information about manipulating
+<li><a href="#Character Set Handling">Character Set Handling</a>, contains information about manipulating
 characters and strings using character sets larger than will fit in
 the usual <code>char</code> data type.
 
 <li><a href="#Locales">Locales</a>, describes how selecting a particular country
 or language affects the behavior of the library.  For example, the locale
 affects collation sequences for strings and how monetary values are
 formatted.
 
-<li><a href="#Non-Local%20Exits">Non-Local Exits</a>, contains descriptions of the <code>setjmp</code> and
+<li><a href="#Non-Local Exits">Non-Local Exits</a>, contains descriptions of the <code>setjmp</code> and
 <code>longjmp</code> functions.  These functions provide a facility for
 <code>goto</code>-like jumps which can jump from one function to another.
 
-<li><a href="#Signal%20Handling">Signal Handling</a>, tells you all about signals--what they are,
+<li><a href="#Signal Handling">Signal Handling</a>, tells you all about signals--what they are,
 how to establish a handler that is called when a particular kind of
 signal is delivered, and how to prevent signals from arriving during
 critical sections of your program.
 
-<li><a href="#Program%20Basics">Program Basics</a>, tells how your programs can access their
+<li><a href="#Program Basics">Program Basics</a>, tells how your programs can access their
 command-line arguments and environment variables.
 
 <li><a href="#Processes">Processes</a>, contains information about how to start new processes
 and run programs.
 
-<li><a href="#Job%20Control">Job Control</a>, describes functions for manipulating process groups
+<li><a href="#Job Control">Job Control</a>, describes functions for manipulating process groups
 and the controlling terminal.  This material is probably only of
 interest if you are writing a shell or other program which handles job
 control specially.
 
-<li><a href="#Name%20Service%20Switch">Name Service Switch</a>, describes the services which are available
+<li><a href="#Name Service Switch">Name Service Switch</a>, describes the services which are available
 for looking up names in the system databases, how to determine which
 service is used for which database, and how these services are
 implemented so that contributors can design their own services.
 
-<li><a href="#User%20Database">User Database</a>, and <a href="#Group%20Database">Group Database</a>, tell you how to access
+<li><a href="#User Database">User Database</a>, and <a href="#Group Database">Group Database</a>, tell you how to access
 the system user and group databases.
 
-<li><a href="#System%20Management">System Management</a>, describes functions for controlling and getting
+<li><a href="#System Management">System Management</a>, describes functions for controlling and getting
 information about the hardware and software configuration your program
 is executing under.
 
-<li><a href="#System%20Configuration">System Configuration</a>, tells you how you can get information about
+<li><a href="#System Configuration">System Configuration</a>, tells you how you can get information about
 various operating system limits.  Most of these parameters are provided for
 compatibility with POSIX.
 
-<li><a href="#Library%20Summary">Library Summary</a>, gives a summary of all the functions, variables, and
+<li><a href="#Library Summary">Library Summary</a>, gives a summary of all the functions, variables, and
 macros in the library, with complete data types and function prototypes,
 and says what standard or system each is derived from.
 
 <li><a href="#Maintenance">Maintenance</a>, explains how to build and install the GNU C library on
@@ -2339,17 +2325,17 @@
 functions or port the library to a new system. 
 </ul>
 
 <p>If you already know the name of the facility you are interested in, you
-can look it up in <a href="#Library%20Summary">Library Summary</a>.  This gives you a summary of
+can look it up in <a href="#Library Summary">Library Summary</a>.  This gives you a summary of
 its syntax and a pointer to where you can find a more detailed
 description.  This appendix is particularly useful if you just want to
 verify the order and type of arguments to a function, for example.  It
 also tells you what standard or system each function, variable, or macro
 is derived from.
 
 <p><hr>
-Node:<a name="Error%20Reporting">Error Reporting</a>,
+Node:<a name="Error Reporting">Error Reporting</a>,
 Next:<a rel=next accesskey=n href="#Memory">Memory</a>,
 Previous:<a rel=previous accesskey=p href="#Introduction">Introduction</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
@@ -2366,18 +2352,18 @@
 program should include the header file <code>errno.h</code> to use this
 facility.
 
 <ul>
-<li><a accesskey=1 href="#Checking%20for%20Errors">Checking for Errors</a>:          How errors are reported by library functions. 
-<li><a accesskey=2 href="#Error%20Codes">Error Codes</a>:                  Error code macros; all of these expand
+<li><a accesskey=1 href="#Checking for Errors">Checking for Errors</a>:          How errors are reported by library functions. 
+<li><a accesskey=2 href="#Error Codes">Error Codes</a>:                  Error code macros; all of these expand
                                  into integer constant values. 
-<li><a accesskey=3 href="#Error%20Messages">Error Messages</a>:               Mapping error codes onto error messages. 
+<li><a accesskey=3 href="#Error Messages">Error Messages</a>:               Mapping error codes onto error messages. 
 </ul>
 
 <p><hr>
-Node:<a name="Checking%20for%20Errors">Checking for Errors</a>,
-Next:<a rel=next accesskey=n href="#Error%20Codes">Error Codes</a>,
-Up:<a rel=up accesskey=u href="#Error%20Reporting">Error Reporting</a>
+Node:<a name="Checking for Errors">Checking for Errors</a>,
+Next:<a rel=next accesskey=n href="#Error Codes">Error Codes</a>,
+Up:<a rel=up accesskey=u href="#Error Reporting">Error Reporting</a>
 <br>
 
 <h3>Checking for Errors</h3>
 
@@ -2389,22 +2375,21 @@
 variable <code>errno</code>.  This variable is declared in the header file
 <code>errno.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">volatile int <b>errno</b><i>
-</i></td>
+<td align="left"><code>volatile int <b>errno</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The variable <code>errno</code> contains the system error number.  You can
 change the value of <code>errno</code>.
 
 <p>Since <code>errno</code> is declared <code>volatile</code>, it might be changed
-asynchronously by a signal handler; see <a href="#Defining%20Handlers">Defining Handlers</a>. 
+asynchronously by a signal handler; see <a href="#Defining Handlers">Defining Handlers</a>. 
 However, a properly written signal handler saves and restores the value
 of <code>errno</code>, so you generally do not need to worry about this
 possibility except when writing signal handlers.
 
@@ -2440,9 +2425,9 @@
 
 <p>All the error codes have symbolic names; they are macros defined in
 <code>errno.h</code>.  The names start with <code>E</code> and an upper-case
 letter or digit; you should consider names of this form to be
-reserved names.  See <a href="#Reserved%20Names">Reserved Names</a>.
+reserved names.  See <a href="#Reserved Names">Reserved Names</a>.
 
 <p>The error code values are all positive integers and are all distinct,
 with one exception: <code>EWOULDBLOCK</code> and <code>EAGAIN</code> are the same. 
 Since the values are distinct, you can use them as labels in a
@@ -2468,12 +2453,12 @@
 happens, you should probably try using statically or dynamically
 allocated memory instead of stack memory on that system.
 
 <p><hr>
-Node:<a name="Error%20Codes">Error Codes</a>,
-Next:<a rel=next accesskey=n href="#Error%20Messages">Error Messages</a>,
-Previous:<a rel=previous accesskey=p href="#Checking%20for%20Errors">Checking for Errors</a>,
-Up:<a rel=up accesskey=u href="#Error%20Reporting">Error Reporting</a>
+Node:<a name="Error Codes">Error Codes</a>,
+Next:<a rel=next accesskey=n href="#Error Messages">Error Messages</a>,
+Previous:<a rel=previous accesskey=p href="#Checking for Errors">Checking for Errors</a>,
+Up:<a rel=up accesskey=u href="#Error Reporting">Error Reporting</a>
 <br>
 
 <h3>Error Codes</h3>
 
@@ -2482,94 +2467,88 @@
 codes can't occur on the GNU system, but they can occur using the GNU
 library on other systems.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPERM</b><i>
-</i></td>
+<td align="left"><code>int <b>EPERM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Operation not permitted; only the owner of the file (or other resource)
 or processes with special privileges can perform the operation. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOENT</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOENT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 No such file or directory.  This is a "file doesn't exist" error
 for ordinary files that are referenced in contexts where they are
 expected to already exist. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ESRCH</b><i>
-</i></td>
+<td align="left"><code>int <b>ESRCH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 No process matches the specified process ID. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EINTR</b><i>
-</i></td>
+<td align="left"><code>int <b>EINTR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Interrupted function call; an asynchronous signal occurred and prevented
 completion of the call.  When this happens, you should try the call
 again.
 
 <p>You can choose to have functions resume after a signal that is handled,
-rather than failing with <code>EINTR</code>; see <a href="#Interrupted%20Primitives">Interrupted Primitives</a>. 
+rather than failing with <code>EINTR</code>; see <a href="#Interrupted Primitives">Interrupted Primitives</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EIO</b><i>
-</i></td>
+<td align="left"><code>int <b>EIO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Input/output error; usually used for physical read or write errors. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENXIO</b><i>
-</i></td>
+<td align="left"><code>int <b>ENXIO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 No such device or address.  The system tried to use the device
 represented by a file you specified, and it couldn't find the device. 
 This can mean that the device file was installed incorrectly, or that
@@ -2578,313 +2557,293 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>E2BIG</b><i>
-</i></td>
+<td align="left"><code>int <b>E2BIG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Argument list too long; used when the arguments passed to a new program
-being executed with one of the <code>exec</code> functions (see <a href="#Executing%20a%20File">Executing a File</a>) occupy too much memory space.  This condition never arises in the
+being executed with one of the <code>exec</code> functions (see <a href="#Executing a File">Executing a File</a>) occupy too much memory space.  This condition never arises in the
 GNU system. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOEXEC</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOEXEC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Invalid executable file format.  This condition is detected by the
-<code>exec</code> functions; see <a href="#Executing%20a%20File">Executing a File</a>. 
+<code>exec</code> functions; see <a href="#Executing a File">Executing a File</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADF</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Bad file descriptor; for example, I/O on a descriptor that has been
 closed or reading from a descriptor open only for writing (or vice
 versa). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ECHILD</b><i>
-</i></td>
+<td align="left"><code>int <b>ECHILD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 There are no child processes.  This error happens on operations that are
 supposed to manipulate child processes, when there aren't any processes
 to manipulate. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EDEADLK</b><i>
-</i></td>
+<td align="left"><code>int <b>EDEADLK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Deadlock avoided; allocating a system resource would have resulted in a
 deadlock situation.  The system does not guarantee that it will notice
 all such situations.  This error means you got lucky and the system
-noticed; it might just hang.  See <a href="#File%20Locks">File Locks</a>, for an example. 
+noticed; it might just hang.  See <a href="#File Locks">File Locks</a>, for an example. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOMEM</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOMEM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 No memory available.  The system cannot allocate more virtual memory
 because its capacity is full. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EACCES</b><i>
-</i></td>
+<td align="left"><code>int <b>EACCES</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Permission denied; the file permissions do not allow the attempted operation. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EFAULT</b><i>
-</i></td>
+<td align="left"><code>int <b>EFAULT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Bad address; an invalid pointer was detected. 
 In the GNU system, this error never happens; you get a signal instead. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTBLK</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTBLK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A file that isn't a block special file was given in a situation that
 requires one.  For example, trying to mount an ordinary file as a file
 system in Unix gives this error. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBUSY</b><i>
-</i></td>
+<td align="left"><code>int <b>EBUSY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Resource busy; a system resource that can't be shared is already in use. 
 For example, if you try to delete a file that is the root of a currently
 mounted filesystem, you get this error. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EEXIST</b><i>
-</i></td>
+<td align="left"><code>int <b>EEXIST</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 File exists; an existing file was specified in a context where it only
 makes sense to specify a new file. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EXDEV</b><i>
-</i></td>
+<td align="left"><code>int <b>EXDEV</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An attempt to make an improper link across file systems was detected. 
-This happens not only when you use <code>link</code> (see <a href="#Hard%20Links">Hard Links</a>) but
-also when you rename a file with <code>rename</code> (see <a href="#Renaming%20Files">Renaming Files</a>). 
+This happens not only when you use <code>link</code> (see <a href="#Hard Links">Hard Links</a>) but
+also when you rename a file with <code>rename</code> (see <a href="#Renaming Files">Renaming Files</a>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENODEV</b><i>
-</i></td>
+<td align="left"><code>int <b>ENODEV</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The wrong type of device was given to a function that expects a
 particular sort of device. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTDIR</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTDIR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A file that isn't a directory was specified when a directory is required. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EISDIR</b><i>
-</i></td>
+<td align="left"><code>int <b>EISDIR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 File is a directory; you cannot open a directory for writing,
 or create or remove hard links to it. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EINVAL</b><i>
-</i></td>
+<td align="left"><code>int <b>EINVAL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Invalid argument.  This is used to indicate various kinds of problems
 with passing the wrong argument to a library function. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EMFILE</b><i>
-</i></td>
+<td align="left"><code>int <b>EMFILE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The current process has too many files open and can't open any more. 
 Duplicate descriptors do count toward this limit.
 
 <p>In BSD and GNU, the number of open files is controlled by a resource
 limit that can usually be increased.  If you get this error, you might
 want to increase the <code>RLIMIT_NOFILE</code> limit or make it unlimited;
-see <a href="#Limits%20on%20Resources">Limits on Resources</a>. 
+see <a href="#Limits on Resources">Limits on Resources</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENFILE</b><i>
-</i></td>
+<td align="left"><code>int <b>ENFILE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 There are too many distinct file openings in the entire system.  Note
 that any number of linked channels count as just one file opening; see
-<a href="#Linked%20Channels">Linked Channels</a>.  This error never occurs in the GNU system. 
+<a href="#Linked Channels">Linked Channels</a>.  This error never occurs in the GNU system. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTTY</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTTY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Inappropriate I/O control operation, such as trying to set terminal
 modes on an ordinary file. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ETXTBSY</b><i>
-</i></td>
+<td align="left"><code>int <b>ETXTBSY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An attempt to execute a file that is currently open for writing, or
 write to a file that is currently being executed.  Often using a
 debugger to run a program is considered having it open for writing and
@@ -2893,89 +2852,83 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EFBIG</b><i>
-</i></td>
+<td align="left"><code>int <b>EFBIG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 File too big; the size of a file would be larger than allowed by the system. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOSPC</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOSPC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 No space left on device; write operation on a file failed because the
 disk is full. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ESPIPE</b><i>
-</i></td>
+<td align="left"><code>int <b>ESPIPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Invalid seek operation (such as on a pipe). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EROFS</b><i>
-</i></td>
+<td align="left"><code>int <b>EROFS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An attempt was made to modify something on a read-only file system. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EMLINK</b><i>
-</i></td>
+<td align="left"><code>int <b>EMLINK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Too many links; the link count of a single file would become too large. 
 <code>rename</code> can cause this error if the file being renamed already has
-as many links as it can take (see <a href="#Renaming%20Files">Renaming Files</a>). 
+as many links as it can take (see <a href="#Renaming Files">Renaming Files</a>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPIPE</b><i>
-</i></td>
+<td align="left"><code>int <b>EPIPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Broken pipe; there is no process reading from the other end of a pipe. 
 Every library function that returns this error code also generates a
 <code>SIGPIPE</code> signal; this signal terminates the program if not handled
@@ -2984,46 +2937,43 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EDOM</b><i>
-</i></td>
+<td align="left"><code>int <b>EDOM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Domain error; used by mathematical functions when an argument value does
 not fall into the domain over which the function is defined. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ERANGE</b><i>
-</i></td>
+<td align="left"><code>int <b>ERANGE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Range error; used by mathematical functions when the result value is
 not representable because of overflow or underflow. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EAGAIN</b><i>
-</i></td>
+<td align="left"><code>int <b>EAGAIN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Resource temporarily unavailable; the call might work if you try again
 later.  The macro <code>EWOULDBLOCK</code> is another name for <code>EAGAIN</code>;
 they are always the same in the GNU C library.
@@ -3034,9 +2984,9 @@
 <li>An operation that would block was attempted on an object that has
 non-blocking mode selected.  Trying the same operation again will block
 until some external condition makes it possible to read, write, or
 connect (whatever the operation).  You can use <code>select</code> to find out
-when the operation will be possible; see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+when the operation will be possible; see <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <p><strong>Portability Note:</strong> In many older Unix systems, this condition
 was indicated by <code>EWOULDBLOCK</code>, which was a distinct error code
 different from <code>EAGAIN</code>.  To make your program portable, you should
@@ -3054,16 +3004,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EWOULDBLOCK</b><i>
-</i></td>
+<td align="left"><code>int <b>EWOULDBLOCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 In the GNU C library, this is another name for <code>EAGAIN</code> (above). 
 The values are always the same, on every operating system.
 
@@ -3072,140 +3021,131 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EINPROGRESS</b><i>
-</i></td>
+<td align="left"><code>int <b>EINPROGRESS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An operation that cannot complete immediately was initiated on an object
 that has non-blocking mode selected.  Some functions that must always
 block (such as <code>connect</code>; see <a href="#Connecting">Connecting</a>) never return
 <code>EAGAIN</code>.  Instead, they return <code>EINPROGRESS</code> to indicate that
 the operation has begun and will take some time.  Attempts to manipulate
 the object before the call completes return <code>EALREADY</code>.  You can
 use the <code>select</code> function to find out when the pending operation
-has completed; see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>. 
+has completed; see <a href="#Waiting for I%2fO">Waiting for I/O</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EALREADY</b><i>
-</i></td>
+<td align="left"><code>int <b>EALREADY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An operation is already in progress on an object that has non-blocking
 mode selected. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTSOCK</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTSOCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A file that isn't a socket was specified when a socket is required. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EMSGSIZE</b><i>
-</i></td>
+<td align="left"><code>int <b>EMSGSIZE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The size of a message sent on a socket was larger than the supported
 maximum size. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPROTOTYPE</b><i>
-</i></td>
+<td align="left"><code>int <b>EPROTOTYPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The socket type does not support the requested communications protocol. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOPROTOOPT</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOPROTOOPT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 You specified a socket option that doesn't make sense for the
-particular protocol being used by the socket.  See <a href="#Socket%20Options">Socket Options</a>. 
+particular protocol being used by the socket.  See <a href="#Socket Options">Socket Options</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPROTONOSUPPORT</b><i>
-</i></td>
+<td align="left"><code>int <b>EPROTONOSUPPORT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The socket domain does not support the requested communications protocol
 (perhaps because the requested protocol is completely invalid). 
-See <a href="#Creating%20a%20Socket">Creating a Socket</a>. 
+See <a href="#Creating a Socket">Creating a Socket</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ESOCKTNOSUPPORT</b><i>
-</i></td>
+<td align="left"><code>int <b>ESOCKTNOSUPPORT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The socket type is not supported. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EOPNOTSUPP</b><i>
-</i></td>
+<td align="left"><code>int <b>EOPNOTSUPP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The operation you requested is not supported.  Some socket functions
 don't make sense for all types of sockets, and others may not be
 implemented for all communications protocols.  In the GNU system, this
@@ -3215,179 +3155,167 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPFNOSUPPORT</b><i>
-</i></td>
+<td align="left"><code>int <b>EPFNOSUPPORT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The socket communications protocol family you requested is not supported. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EAFNOSUPPORT</b><i>
-</i></td>
+<td align="left"><code>int <b>EAFNOSUPPORT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The address family specified for a socket is not supported; it is
 inconsistent with the protocol being used on the socket.  See <a href="#Sockets">Sockets</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EADDRINUSE</b><i>
-</i></td>
+<td align="left"><code>int <b>EADDRINUSE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-The requested socket address is already in use.  See <a href="#Socket%20Addresses">Socket Addresses</a>. 
+The requested socket address is already in use.  See <a href="#Socket Addresses">Socket Addresses</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EADDRNOTAVAIL</b><i>
-</i></td>
+<td align="left"><code>int <b>EADDRNOTAVAIL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The requested socket address is not available; for example, you tried
 to give a socket a name that doesn't match the local host name. 
-See <a href="#Socket%20Addresses">Socket Addresses</a>. 
+See <a href="#Socket Addresses">Socket Addresses</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENETDOWN</b><i>
-</i></td>
+<td align="left"><code>int <b>ENETDOWN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A socket operation failed because the network was down. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENETUNREACH</b><i>
-</i></td>
+<td align="left"><code>int <b>ENETUNREACH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A socket operation failed because the subnet containing the remote host
 was unreachable. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENETRESET</b><i>
-</i></td>
+<td align="left"><code>int <b>ENETRESET</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A network connection was reset because the remote host crashed. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ECONNABORTED</b><i>
-</i></td>
+<td align="left"><code>int <b>ECONNABORTED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A network connection was aborted locally. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ECONNRESET</b><i>
-</i></td>
+<td align="left"><code>int <b>ECONNRESET</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A network connection was closed for reasons outside the control of the
 local host, such as by the remote machine rebooting or an unrecoverable
 protocol violation. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOBUFS</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOBUFS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The kernel's buffers for I/O operations are all in use.  In GNU, this
 error is always synonymous with <code>ENOMEM</code>; you may get one or the
 other from network operations. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EISCONN</b><i>
-</i></td>
+<td align="left"><code>int <b>EISCONN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 You tried to connect a socket that is already connected. 
 See <a href="#Connecting">Connecting</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTCONN</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTCONN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The socket is not connected to anything.  You get this error when you
 try to transmit data over a socket, without first specifying a
 destination for the data.  For a connectionless socket (for datagram
@@ -3395,207 +3323,193 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EDESTADDRREQ</b><i>
-</i></td>
+<td align="left"><code>int <b>EDESTADDRREQ</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 No default destination address was set for the socket.  You get this
 error when you try to transmit data over a connectionless socket,
 without first specifying a destination for the data with <code>connect</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ESHUTDOWN</b><i>
-</i></td>
+<td align="left"><code>int <b>ESHUTDOWN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The socket has already been shut down. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ETOOMANYREFS</b><i>
-</i></td>
+<td align="left"><code>int <b>ETOOMANYREFS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ETIMEDOUT</b><i>
-</i></td>
+<td align="left"><code>int <b>ETIMEDOUT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A socket operation with a specified timeout received no response during
 the timeout period. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ECONNREFUSED</b><i>
-</i></td>
+<td align="left"><code>int <b>ECONNREFUSED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A remote host refused to allow the network connection (typically because
 it is not running the requested service). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ELOOP</b><i>
-</i></td>
+<td align="left"><code>int <b>ELOOP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Too many levels of symbolic links were encountered in looking up a file name. 
 This often indicates a cycle of symbolic links. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENAMETOOLONG</b><i>
-</i></td>
+<td align="left"><code>int <b>ENAMETOOLONG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-Filename too long (longer than <code>PATH_MAX</code>; see <a href="#Limits%20for%20Files">Limits for Files</a>) or host name too long (in <code>gethostname</code> or
-<code>sethostname</code>; see <a href="#Host%20Identification">Host Identification</a>). 
+Filename too long (longer than <code>PATH_MAX</code>; see <a href="#Limits for Files">Limits for Files</a>) or host name too long (in <code>gethostname</code> or
+<code>sethostname</code>; see <a href="#Host Identification">Host Identification</a>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EHOSTDOWN</b><i>
-</i></td>
+<td align="left"><code>int <b>EHOSTDOWN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The remote host for a requested network connection is down. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EHOSTUNREACH</b><i>
-</i></td>
+<td align="left"><code>int <b>EHOSTUNREACH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The remote host for a requested network connection is not reachable. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTEMPTY</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTEMPTY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Directory not empty, where an empty directory was expected.  Typically,
 this error occurs when you are trying to delete a directory. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPROCLIM</b><i>
-</i></td>
+<td align="left"><code>int <b>EPROCLIM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This means that the per-user limit on new process would be exceeded by
-an attempted <code>fork</code>.  See <a href="#Limits%20on%20Resources">Limits on Resources</a>, for details on
+an attempted <code>fork</code>.  See <a href="#Limits on Resources">Limits on Resources</a>, for details on
 the <code>RLIMIT_NPROC</code> limit. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EUSERS</b><i>
-</i></td>
+<td align="left"><code>int <b>EUSERS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The file quota system is confused because there are too many users. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EDQUOT</b><i>
-</i></td>
+<td align="left"><code>int <b>EDQUOT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The user's disk quota was exceeded. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ESTALE</b><i>
-</i></td>
+<td align="left"><code>int <b>ESTALE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Stale NFS file handle.  This indicates an internal confusion in the NFS
 system which is due to file system rearrangements on the server host. 
 Repairing this condition usually requires unmounting and remounting
@@ -3603,16 +3517,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EREMOTE</b><i>
-</i></td>
+<td align="left"><code>int <b>EREMOTE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An attempt was made to NFS-mount a remote file system with a file name that
 already specifies an NFS-mounted file. 
 (This is an error on some operating systems, but we expect it to work
@@ -3620,149 +3533,139 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADRPC</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADRPC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ERPCMISMATCH</b><i>
-</i></td>
+<td align="left"><code>int <b>ERPCMISMATCH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPROGUNAVAIL</b><i>
-</i></td>
+<td align="left"><code>int <b>EPROGUNAVAIL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPROGMISMATCH</b><i>
-</i></td>
+<td align="left"><code>int <b>EPROGMISMATCH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPROCUNAVAIL</b><i>
-</i></td>
+<td align="left"><code>int <b>EPROCUNAVAIL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOLCK</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOLCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 No locks available.  This is used by the file locking facilities; see
-<a href="#File%20Locks">File Locks</a>.  This error is never generated by the GNU system, but
+<a href="#File Locks">File Locks</a>.  This error is never generated by the GNU system, but
 it can result from an operation to an NFS server running another
 operating system. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EFTYPE</b><i>
-</i></td>
+<td align="left"><code>int <b>EFTYPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Inappropriate file type or format.  The file was the wrong type for the
 operation, or a data file had the wrong format.
 
 <p>On some systems <code>chmod</code> returns this error if you try to set the
-sticky bit on a non-directory file; see <a href="#Setting%20Permissions">Setting Permissions</a>. 
+sticky bit on a non-directory file; see <a href="#Setting Permissions">Setting Permissions</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EAUTH</b><i>
-</i></td>
+<td align="left"><code>int <b>EAUTH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENEEDAUTH</b><i>
-</i></td>
+<td align="left"><code>int <b>ENEEDAUTH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 ??? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOSYS</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOSYS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Function not implemented.  This indicates that the function called is
 not implemented at all, either in the C library itself or in the
 operating system.  When you get this error, you can be sure that this
@@ -3771,16 +3674,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTSUP</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTSUP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Not supported.  A function returns this error when certain parameter
 values are valid, but the functionality they request is not available. 
 This can mean that the function does not implement a particular command
@@ -3796,770 +3698,713 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EILSEQ</b><i>
-</i></td>
+<td align="left"><code>int <b>EILSEQ</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 While decoding a multibyte character the function came along an invalid
 or an incomplete sequence of bytes or the given wide character is invalid. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBACKGROUND</b><i>
-</i></td>
+<td align="left"><code>int <b>EBACKGROUND</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 In the GNU system, servers supporting the <code>term</code> protocol return
 this error for certain operations when the caller is not in the
 foreground process group of the terminal.  Users do not usually see this
 error because functions such as <code>read</code> and <code>write</code> translate
-it into a <code>SIGTTIN</code> or <code>SIGTTOU</code> signal.  See <a href="#Job%20Control">Job Control</a>,
+it into a <code>SIGTTIN</code> or <code>SIGTTOU</code> signal.  See <a href="#Job Control">Job Control</a>,
 for information on process groups and these signals. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EDIED</b><i>
-</i></td>
+<td align="left"><code>int <b>EDIED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 In the GNU system, opening a file returns this error when the file is
 translated by a program and the translator program dies while starting
 up, before it has connected to the file. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ED</b><i>
-</i></td>
+<td align="left"><code>int <b>ED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The experienced user will know what is wrong. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EGREGIOUS</b><i>
-</i></td>
+<td align="left"><code>int <b>EGREGIOUS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 You did <strong>what</strong>? 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EIEIO</b><i>
-</i></td>
+<td align="left"><code>int <b>EIEIO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Go home and have a glass of warm, dairy-fresh milk. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EGRATUITOUS</b><i>
-</i></td>
+<td align="left"><code>int <b>EGRATUITOUS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This error code has no purpose. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADMSG</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADMSG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EIDRM</b><i>
-</i></td>
+<td align="left"><code>int <b>EIDRM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EMULTIHOP</b><i>
-</i></td>
+<td align="left"><code>int <b>EMULTIHOP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENODATA</b><i>
-</i></td>
+<td align="left"><code>int <b>ENODATA</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOLINK</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOLINK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOMSG</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOMSG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOSR</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOSR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOSTR</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOSTR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EOVERFLOW</b><i>
-</i></td>
+<td align="left"><code>int <b>EOVERFLOW</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EPROTO</b><i>
-</i></td>
+<td align="left"><code>int <b>EPROTO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ETIME</b><i>
-</i></td>
+<td align="left"><code>int <b>ETIME</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p><em>The following error codes are defined by the Linux/i386 kernel. 
 They are not yet documented.</em>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ERESTART</b><i>
-</i></td>
+<td align="left"><code>int <b>ERESTART</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ECHRNG</b><i>
-</i></td>
+<td align="left"><code>int <b>ECHRNG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EL2NSYNC</b><i>
-</i></td>
+<td align="left"><code>int <b>EL2NSYNC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EL3HLT</b><i>
-</i></td>
+<td align="left"><code>int <b>EL3HLT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EL3RST</b><i>
-</i></td>
+<td align="left"><code>int <b>EL3RST</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ELNRNG</b><i>
-</i></td>
+<td align="left"><code>int <b>ELNRNG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EUNATCH</b><i>
-</i></td>
+<td align="left"><code>int <b>EUNATCH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOCSI</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOCSI</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EL2HLT</b><i>
-</i></td>
+<td align="left"><code>int <b>EL2HLT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADE</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADR</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EXFULL</b><i>
-</i></td>
+<td align="left"><code>int <b>EXFULL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOANO</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOANO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADRQC</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADRQC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADSLT</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADSLT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EDEADLOCK</b><i>
-</i></td>
+<td align="left"><code>int <b>EDEADLOCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBFONT</b><i>
-</i></td>
+<td align="left"><code>int <b>EBFONT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENONET</b><i>
-</i></td>
+<td align="left"><code>int <b>ENONET</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOPKG</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOPKG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EADV</b><i>
-</i></td>
+<td align="left"><code>int <b>EADV</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ESRMNT</b><i>
-</i></td>
+<td align="left"><code>int <b>ESRMNT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ECOMM</b><i>
-</i></td>
+<td align="left"><code>int <b>ECOMM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EDOTDOT</b><i>
-</i></td>
+<td align="left"><code>int <b>EDOTDOT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTUNIQ</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTUNIQ</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EBADFD</b><i>
-</i></td>
+<td align="left"><code>int <b>EBADFD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EREMCHG</b><i>
-</i></td>
+<td align="left"><code>int <b>EREMCHG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ELIBACC</b><i>
-</i></td>
+<td align="left"><code>int <b>ELIBACC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ELIBBAD</b><i>
-</i></td>
+<td align="left"><code>int <b>ELIBBAD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ELIBSCN</b><i>
-</i></td>
+<td align="left"><code>int <b>ELIBSCN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ELIBMAX</b><i>
-</i></td>
+<td align="left"><code>int <b>ELIBMAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ELIBEXEC</b><i>
-</i></td>
+<td align="left"><code>int <b>ELIBEXEC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ESTRPIPE</b><i>
-</i></td>
+<td align="left"><code>int <b>ESTRPIPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EUCLEAN</b><i>
-</i></td>
+<td align="left"><code>int <b>EUCLEAN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOTNAM</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOTNAM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENAVAIL</b><i>
-</i></td>
+<td align="left"><code>int <b>ENAVAIL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EISNAM</b><i>
-</i></td>
+<td align="left"><code>int <b>EISNAM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EREMOTEIO</b><i>
-</i></td>
+<td align="left"><code>int <b>EREMOTEIO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ENOMEDIUM</b><i>
-</i></td>
+<td align="left"><code>int <b>ENOMEDIUM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EMEDIUMTYPE</b><i>
-</i></td>
+<td align="left"><code>int <b>EMEDIUMTYPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Error%20Messages">Error Messages</a>,
-Previous:<a rel=previous accesskey=p href="#Error%20Codes">Error Codes</a>,
-Up:<a rel=up accesskey=u href="#Error%20Reporting">Error Reporting</a>
+Node:<a name="Error Messages">Error Messages</a>,
+Previous:<a rel=previous accesskey=p href="#Error Codes">Error Codes</a>,
+Up:<a rel=up accesskey=u href="#Error Reporting">Error Reporting</a>
 <br>
 
 <h3>Error Messages</h3>
 
@@ -4571,18 +4416,17 @@
 <code>program_invocation_short_name</code> gives you convenient access to the
 name of the program that encountered the error.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strerror</b><i> (int <var>errnum</var>)
-</i></td>
+<td align="left"><code>char * <b>strerror</b><i> (int <var>errnum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-The <code>strerror</code> function maps the error code (see <a href="#Checking%20for%20Errors">Checking for Errors</a>) specified by the <var>errnum</var> argument to a descriptive error
+The <code>strerror</code> function maps the error code (see <a href="#Checking for Errors">Checking for Errors</a>) specified by the <var>errnum</var> argument to a descriptive error
 message string.  The return value is a pointer to this string.
 
 <p>The value <var>errnum</var> normally comes from the variable <code>errno</code>.
 
@@ -4595,16 +4439,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strerror_r</b><i> (int <var>errnum</var>, char *<var>buf</var>, size_t <var>n</var>)
-</i></td>
+<td align="left"><code>char * <b>strerror_r</b><i> (int <var>errnum</var>, char *<var>buf</var>, size_t <var>n</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strerror_r</code> function works like <code>strerror</code> but instead of
 returning the error message in a statically allocated buffer shared by
 all threads in the process, it returns a private copy for the
@@ -4624,19 +4467,18 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>perror</b><i> (const char *<var>message</var>)
-</i></td>
+<td align="left"><code>void <b>perror</b><i> (const char *<var>message</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function prints an error message to the stream <code>stderr</code>;
-see <a href="#Standard%20Streams">Standard Streams</a>.  The orientation of <code>stderr</code> is not
+see <a href="#Standard Streams">Standard Streams</a>.  The orientation of <code>stderr</code> is not
 changed.
 
 <p>If you call <code>perror</code> with a <var>message</var> that is either a null
 pointer or an empty string, <code>perror</code> just prints the error message
@@ -4667,33 +4509,31 @@
 <code>program_invocation_short_name</code>; the full file name is stored the
 variable <code>program_invocation_name</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>program_invocation_name</b><i>
-</i></td>
+<td align="left"><code>char * <b>program_invocation_name</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This variable's value is the name that was used to invoke the program
 running in the current process.  It is the same as <code>argv[0]</code>.  Note
 that this is not necessarily a useful file name; often it contains no
-directory names.  See <a href="#Program%20Arguments">Program Arguments</a>. 
+directory names.  See <a href="#Program Arguments">Program Arguments</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>program_invocation_short_name</b><i>
-</i></td>
+<td align="left"><code>char * <b>program_invocation_short_name</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This variable's value is the name that was used to invoke the program
 running in the current process, with directory names removed.  (That is
 to say, it is the same as <code>program_invocation_name</code> minus
@@ -4756,16 +4596,15 @@
 functions available which are widely used throughout the GNU project. 
 These functions are declared in <code>error.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>error</b><i> (int <var>status</var>, int <var>errnum</var>, const char *<var>format</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>error</b><i> (int <var>status</var>, int <var>errnum</var>, const char *<var>format</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>error</code> function can be used to report general problems during
 program execution.  The <var>format</var> argument is a format string just
 like those given to the <code>printf</code> family of functions.  The
@@ -4799,16 +4638,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>error_at_line</b><i> (int <var>status</var>, int <var>errnum</var>, const char *<var>fname</var>, unsigned int <var>lineno</var>, const char *<var>format</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>error_at_line</b><i> (int <var>status</var>, int <var>errnum</var>, const char *<var>fname</var>, unsigned int <var>lineno</var>, const char *<var>format</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>error_at_line</code> function is very similar to the <code>error</code>
 function.  The only difference are the additional parameters <var>fname</var>
@@ -4839,16 +4677,15 @@
 can be customized by defining a variable named
 <code>error_print_progname</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void (* <b>error_print_progname</b><i> ) (void)
-</i></td>
+<td align="left"><code>void (* <b>error_print_progname</b><i> ) (void)</i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the <code>error_print_progname</code> variable is defined to a non-zero
 value the function pointed to is called by <code>error</code> or
 <code>error_at_line</code>.  It is expected to print the program name or do
@@ -4861,32 +4698,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned int <b>error_message_count</b><i>
-</i></td>
+<td align="left"><code>unsigned int <b>error_message_count</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>error_message_count</code> variable is incremented whenever one of
 the functions <code>error</code> or <code>error_at_line</code> returns.  The
 variable is global and shared by all threads. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>error_one_per_line</b><i>
-</i></td>
+<td align="left"><code>int <b>error_one_per_line</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>error_one_per_line</code> variable influences only
 <code>error_at_line</code>.  Normally the <code>error_at_line</code> function
 creates output for every invocation.  If <code>error_one_per_line</code> is
@@ -4934,16 +4769,15 @@
 <code>err.h</code>.  It is generally advised to not use these functions.  They
 are included only for compatibility.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>warn</b><i> (const char *<var>format</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>warn</b><i> (const char *<var>format</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>warn</code> function is roughly equivalent to a call like
 <br><pre>  error (0, errno, format, the parameters)
 </pre>
@@ -4953,32 +4787,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>vwarn</b><i> (const char *<var>format</var>, va_list)
-</i></td>
+<td align="left"><code>void <b>vwarn</b><i> (const char *<var>format</var>, va_list)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>vwarn</code> function is just like <code>warn</code> except that the
 parameters for the handling of the format string <var>format</var> are passed
 in as an value of type <code>va_list</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>warnx</b><i> (const char *<var>format</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>warnx</b><i> (const char *<var>format</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>warnx</code> function is roughly equivalent to a call like
 <br><pre>  error (0, 0, format, the parameters)
 </pre>
@@ -4989,32 +4821,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>vwarnx</b><i> (const char *<var>format</var>, va_list)
-</i></td>
+<td align="left"><code>void <b>vwarnx</b><i> (const char *<var>format</var>, va_list)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>vwarnx</code> function is just like <code>warnx</code> except that the
 parameters for the handling of the format string <var>format</var> are passed
 in as an value of type <code>va_list</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>err</b><i> (int <var>status</var>, const char *<var>format</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>err</b><i> (int <var>status</var>, const char *<var>format</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>err</code> function is roughly equivalent to a call like
 <br><pre>  error (status, errno, format, the parameters)
 </pre>
@@ -5024,32 +4854,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>verr</b><i> (int <var>status</var>, const char *<var>format</var>, va_list)
-</i></td>
+<td align="left"><code>void <b>verr</b><i> (int <var>status</var>, const char *<var>format</var>, va_list)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>verr</code> function is just like <code>err</code> except that the
 parameters for the handling of the format string <var>format</var> are passed
 in as an value of type <code>va_list</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>errx</b><i> (int <var>status</var>, const char *<var>format</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>errx</b><i> (int <var>status</var>, const char *<var>format</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>errx</code> function is roughly equivalent to a call like
 <br><pre>  error (status, 0, format, the parameters)
 </pre>
@@ -5061,16 +4889,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>verrx</b><i> (int <var>status</var>, const char *<var>format</var>, va_list)
-</i></td>
+<td align="left"><code>void <b>verrx</b><i> (int <var>status</var>, const char *<var>format</var>, va_list)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>verrx</code> function is just like <code>errx</code> except that the
 parameters for the handling of the format string <var>format</var> are passed
 in as an value of type <code>va_list</code>. 
@@ -5078,10 +4905,10 @@
 </table>
 
 <p><hr>
 Node:<a name="Memory">Memory</a>,
-Next:<a rel=next accesskey=n href="#Character%20Handling">Character Handling</a>,
-Previous:<a rel=previous accesskey=p href="#Error%20Reporting">Error Reporting</a>,
+Next:<a rel=next accesskey=n href="#Character Handling">Character Handling</a>,
+Previous:<a rel=previous accesskey=p href="#Error Reporting">Error Reporting</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Virtual Memory Allocation And Paging</h2>
@@ -5094,19 +4921,19 @@
 efficiency.  The library also provides functions for controlling paging
 and allocation of real memory.
 
 <ul>
-<li><a accesskey=1 href="#Memory%20Concepts">Memory Concepts</a>:              An introduction to concepts and terminology. 
-<li><a accesskey=2 href="#Memory%20Allocation">Memory Allocation</a>:            Allocating storage for your program data
-<li><a accesskey=3 href="#Locking%20Pages">Locking Pages</a>:                Preventing page faults
-<li><a accesskey=4 href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>:    <code>brk</code>, <code>sbrk</code>
+<li><a accesskey=1 href="#Memory Concepts">Memory Concepts</a>:              An introduction to concepts and terminology. 
+<li><a accesskey=2 href="#Memory Allocation">Memory Allocation</a>:            Allocating storage for your program data
+<li><a accesskey=3 href="#Locking Pages">Locking Pages</a>:                Preventing page faults
+<li><a accesskey=4 href="#Resizing the Data Segment">Resizing the Data Segment</a>:    <code>brk</code>, <code>sbrk</code>
 </ul>
 
-<p>Memory mapped I/O is not discussed in this chapter.  See <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+<p>Memory mapped I/O is not discussed in this chapter.  See <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <p><hr>
-Node:<a name="Memory%20Concepts">Memory Concepts</a>,
-Next:<a rel=next accesskey=n href="#Memory%20Allocation">Memory Allocation</a>,
+Node:<a name="Memory Concepts">Memory Concepts</a>,
+Next:<a rel=next accesskey=n href="#Memory Allocation">Memory Allocation</a>,
 Up:<a rel=up accesskey=u href="#Memory">Memory</a>
 <br>
 
 <h3>Process Memory Concepts</h3>
@@ -5149,9 +4976,9 @@
 seem to be in real memory.  Except for one thing: the elapsed execution
 time of an instruction that would normally be a few nanoseconds is
 suddenly much, much, longer (because the kernel normally has to do I/O
 to complete the page-in).  For programs sensitive to that, the functions
-described in <a href="#Locking%20Pages">Locking Pages</a> can control it.
+described in <a href="#Locking Pages">Locking Pages</a> can control it.
 
 <p>Within each virtual address space, a process has to keep track of what
 is at which addresses, and that process is called memory allocation. 
 Allocation usually brings to mind meting out scarce resources, but in
@@ -5161,23 +4988,23 @@
 memory isn't used to store two different things.
 
 <p>Processes allocate memory in two major ways: by exec and
 programmatically.  Actually, forking is a third way, but it's not very
-interesting.  See <a href="#Creating%20a%20Process">Creating a Process</a>.
+interesting.  See <a href="#Creating a Process">Creating a Process</a>.
 
 <p>Exec is the operation of creating a virtual address space for a process,
 loading its basic program into it, and executing the program.  It is
 done by the "exec" family of functions (e.g. <code>execl</code>).  The
 operation takes a program file (an executable), it allocates space to
 load all the data in the executable, loads it, and transfers control to
 it.  That data is most notably the instructions of the program (the
 <dfn>text</dfn>), but also literals and constants in the program and even
-some variables: C variables with the static storage class (see <a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>).
+some variables: C variables with the static storage class (see <a href="#Memory Allocation and C">Memory Allocation and C</a>).
 
 <p>Once that program begins to execute, it uses programmatic allocation to
 gain additional memory.  In a C program with the GNU C library, there
 are two kinds of programmatic allocation: automatic and dynamic. 
-See <a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>.
+See <a href="#Memory Allocation and C">Memory Allocation and C</a>.
 
 <p>Memory-mapped I/O is another form of dynamic virtual memory allocation. 
 Mapping memory to a file means declaring that the contents of certain
 range of a process' addresses shall be identical to the contents of a
@@ -5186,15 +5013,15 @@
 system writes the same modification to the file.  Note that due to the
 magic of virtual memory and page faults, there is no reason for the
 system to do I/O to read the file, or allocate real memory for its
 contents, until the program accesses the virtual memory. 
-See <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+See <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <p>Just as it programmatically allocates memory, the program can
 programmatically deallocate (<dfn>free</dfn>) it.  You can't free the memory
 that was allocated by exec.  When the program exits or execs, you might
 say that all its memory gets freed, but since in both cases the address
-space ceases to exist, the point is really moot.  See <a href="#Program%20Termination">Program Termination</a>.
+space ceases to exist, the point is really moot.  See <a href="#Program Termination">Program Termination</a>.
 
 <p>A process' virtual address space is divided into segments.  A segment is
 a contiguous range of virtual addresses.  Three important segments are:
 
@@ -5206,19 +5033,19 @@
 the life of the virtual address space.
 
 <li>The <dfn>data segment</dfn> is working storage for the program.  It can be
 preallocated and preloaded by exec and the process can extend or shrink
-it by calling functions as described in See <a href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>.  Its lower end is fixed.
+it by calling functions as described in See <a href="#Resizing the Data Segment">Resizing the Data Segment</a>.  Its lower end is fixed.
 
 <li>The <dfn>stack segment</dfn> contains a program stack.  It grows as the stack
 grows, but doesn't shrink when the stack shrinks.
 
 </ul>
 
 <p><hr>
-Node:<a name="Memory%20Allocation">Memory Allocation</a>,
-Next:<a rel=next accesskey=n href="#Locking%20Pages">Locking Pages</a>,
-Previous:<a rel=previous accesskey=p href="#Memory%20Concepts">Memory Concepts</a>,
+Node:<a name="Memory Allocation">Memory Allocation</a>,
+Next:<a rel=next accesskey=n href="#Locking Pages">Locking Pages</a>,
+Previous:<a rel=previous accesskey=p href="#Memory Concepts">Memory Concepts</a>,
 Up:<a rel=up accesskey=u href="#Memory">Memory</a>
 <br>
 
 <h3>Allocating Storage For Program Data</h3>
@@ -5227,23 +5054,23 @@
 including the famous <code>malloc</code> function and some fancier facilities
 special the GNU C library and GNU Compiler.
 
 <ul>
-<li><a accesskey=1 href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>:      How to get different kinds of allocation in C. 
-<li><a accesskey=2 href="#Unconstrained%20Allocation">Unconstrained Allocation</a>:     The <code>malloc</code> facility allows fully general
+<li><a accesskey=1 href="#Memory Allocation and C">Memory Allocation and C</a>:      How to get different kinds of allocation in C. 
+<li><a accesskey=2 href="#Unconstrained Allocation">Unconstrained Allocation</a>:     The <code>malloc</code> facility allows fully general
 		 		 dynamic allocation. 
-<li><a accesskey=3 href="#Allocation%20Debugging">Allocation Debugging</a>:         Finding memory leaks and not freed memory. 
+<li><a accesskey=3 href="#Allocation Debugging">Allocation Debugging</a>:         Finding memory leaks and not freed memory. 
 <li><a accesskey=4 href="#Obstacks">Obstacks</a>:                     Obstacks are less general than malloc
 				 but more efficient and convenient. 
-<li><a accesskey=5 href="#Variable%20Size%20Automatic">Variable Size Automatic</a>:      Allocation of variable-sized blocks
+<li><a accesskey=5 href="#Variable Size Automatic">Variable Size Automatic</a>:      Allocation of variable-sized blocks
 				 of automatic storage that are freed when the
 				 calling function returns. 
 </ul>
 
 <p><hr>
-Node:<a name="Memory%20Allocation%20and%20C">Memory Allocation and C</a>,
-Next:<a rel=next accesskey=n href="#Unconstrained%20Allocation">Unconstrained Allocation</a>,
-Up:<a rel=up accesskey=u href="#Memory%20Allocation">Memory Allocation</a>
+Node:<a name="Memory Allocation and C">Memory Allocation and C</a>,
+Next:<a rel=next accesskey=n href="#Unconstrained Allocation">Unconstrained Allocation</a>,
+Up:<a rel=up accesskey=u href="#Memory Allocation">Memory Allocation</a>
 <br>
 
 <h4>Memory Allocation in C Programs</h4>
 
@@ -5320,12 +5147,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Unconstrained%20Allocation">Unconstrained Allocation</a>,
-Next:<a rel=next accesskey=n href="#Allocation%20Debugging">Allocation Debugging</a>,
-Previous:<a rel=previous accesskey=p href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>,
-Up:<a rel=up accesskey=u href="#Memory%20Allocation">Memory Allocation</a>
+Node:<a name="Unconstrained Allocation">Unconstrained Allocation</a>,
+Next:<a rel=next accesskey=n href="#Allocation Debugging">Allocation Debugging</a>,
+Previous:<a rel=previous accesskey=p href="#Memory Allocation and C">Memory Allocation and C</a>,
+Up:<a rel=up accesskey=u href="#Memory Allocation">Memory Allocation</a>
 <br>
 
 <h4>Unconstrained Allocation</h4>
 
@@ -5334,61 +5161,60 @@
 them bigger or smaller at any time, and free the blocks individually at
 any time (or never).
 
 <ul>
-<li><a accesskey=1 href="#Basic%20Allocation">Basic Allocation</a>:             Simple use of <code>malloc</code>. 
-<li><a accesskey=2 href="#Malloc%20Examples">Malloc Examples</a>:              Examples of <code>malloc</code>.  <code>xmalloc</code>. 
-<li><a accesskey=3 href="#Freeing%20after%20Malloc">Freeing after Malloc</a>:         Use <code>free</code> to free a block you
+<li><a accesskey=1 href="#Basic Allocation">Basic Allocation</a>:             Simple use of <code>malloc</code>. 
+<li><a accesskey=2 href="#Malloc Examples">Malloc Examples</a>:              Examples of <code>malloc</code>.  <code>xmalloc</code>. 
+<li><a accesskey=3 href="#Freeing after Malloc">Freeing after Malloc</a>:         Use <code>free</code> to free a block you
 				 got with <code>malloc</code>. 
-<li><a accesskey=4 href="#Changing%20Block%20Size">Changing Block Size</a>:          Use <code>realloc</code> to make a block
+<li><a accesskey=4 href="#Changing Block Size">Changing Block Size</a>:          Use <code>realloc</code> to make a block
 				 bigger or smaller. 
-<li><a accesskey=5 href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>:     Use <code>calloc</code> to allocate a
+<li><a accesskey=5 href="#Allocating Cleared Space">Allocating Cleared Space</a>:     Use <code>calloc</code> to allocate a
 				 block and clear it. 
-<li><a accesskey=6 href="#Efficiency%20and%20Malloc">Efficiency and Malloc</a>:        Efficiency considerations in use of
+<li><a accesskey=6 href="#Efficiency and Malloc">Efficiency and Malloc</a>:        Efficiency considerations in use of
 				 these functions. 
-<li><a accesskey=7 href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>:        Allocating specially aligned memory. 
-<li><a accesskey=8 href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>:    Use <code>mallopt</code> to adjust allocation
+<li><a accesskey=7 href="#Aligned Memory Blocks">Aligned Memory Blocks</a>:        Allocating specially aligned memory. 
+<li><a accesskey=8 href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>:    Use <code>mallopt</code> to adjust allocation
                                  parameters. 
-<li><a accesskey=9 href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>:    Automatic checking for errors. 
-<li><a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>:             You can use these hooks for debugging
+<li><a accesskey=9 href="#Heap Consistency Checking">Heap Consistency Checking</a>:    Automatic checking for errors. 
+<li><a href="#Hooks for Malloc">Hooks for Malloc</a>:             You can use these hooks for debugging
 				 programs that use <code>malloc</code>. 
-<li><a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>:         Getting information about how much
+<li><a href="#Statistics of Malloc">Statistics of Malloc</a>:         Getting information about how much
 				 memory your program is using. 
-<li><a href="#Summary%20of%20Malloc">Summary of Malloc</a>:            Summary of <code>malloc</code> and related functions. 
+<li><a href="#Summary of Malloc">Summary of Malloc</a>:            Summary of <code>malloc</code> and related functions. 
 </ul>
 
 <p><hr>
-Node:<a name="Basic%20Allocation">Basic Allocation</a>,
-Next:<a rel=next accesskey=n href="#Malloc%20Examples">Malloc Examples</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Basic Allocation">Basic Allocation</a>,
+Next:<a rel=next accesskey=n href="#Malloc Examples">Malloc Examples</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Basic Memory Allocation</h5>
 
 <p>To allocate a block of memory, call <code>malloc</code>.  The prototype for
 this function is in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>malloc</b><i> (size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>malloc</b><i> (size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a pointer to a newly allocated block <var>size</var>
 bytes long, or a null pointer if the block could not be allocated. 
 </td></tr>
 </table>
 
 <p>The contents of the block are undefined; you must initialize it yourself
-(or use <code>calloc</code> instead; see <a href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>). 
+(or use <code>calloc</code> instead; see <a href="#Allocating Cleared Space">Allocating Cleared Space</a>). 
 Normally you would cast the value as a pointer to the kind of object
 that you want to store in the block.  Here we show an example of doing
 so, and of initializing the space with zeros using the library function
-<code>memset</code> (see <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>):
+<code>memset</code> (see <a href="#Copying and Concatenation">Copying and Concatenation</a>):
 
 <br><pre>struct foo *ptr;
 <small>...</small>
 ptr = (struct foo *) malloc (sizeof (struct foo));
@@ -5411,15 +5237,15 @@
 <small>...</small>
 ptr = (char *) malloc (length + 1);
 </pre>
 
-<p>See <a href="#Representation%20of%20Strings">Representation of Strings</a>, for more information about this.
+<p>See <a href="#Representation of Strings">Representation of Strings</a>, for more information about this.
 
 <p><hr>
-Node:<a name="Malloc%20Examples">Malloc Examples</a>,
-Next:<a rel=next accesskey=n href="#Freeing%20after%20Malloc">Freeing after Malloc</a>,
-Previous:<a rel=previous accesskey=p href="#Basic%20Allocation">Basic Allocation</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Malloc Examples">Malloc Examples</a>,
+Next:<a rel=next accesskey=n href="#Freeing after Malloc">Freeing after Malloc</a>,
+Previous:<a rel=previous accesskey=p href="#Basic Allocation">Basic Allocation</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Examples of <code>malloc</code></h5>
 
@@ -5457,23 +5283,23 @@
 that it can hold any type of data.  In the GNU system, the address is
 always a multiple of eight on most systems, and a multiple of 16 on
 64-bit systems.  Only rarely is any higher boundary (such as a page
 boundary) necessary; for those cases, use <code>memalign</code>,
-<code>posix_memalign</code> or <code>valloc</code> (see <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>).
+<code>posix_memalign</code> or <code>valloc</code> (see <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>).
 
 <p>Note that the memory located after the end of the block is likely to be
 in use for something else; perhaps a block already allocated by another
 call to <code>malloc</code>.  If you attempt to treat the block as longer than
 you asked for it to be, you are liable to destroy the data that
 <code>malloc</code> uses to keep track of its blocks, or you may destroy the
 contents of another block.  If you have already allocated a block and
-discover you want it to be bigger, use <code>realloc</code> (see <a href="#Changing%20Block%20Size">Changing Block Size</a>).
+discover you want it to be bigger, use <code>realloc</code> (see <a href="#Changing Block Size">Changing Block Size</a>).
 
 <p><hr>
-Node:<a name="Freeing%20after%20Malloc">Freeing after Malloc</a>,
-Next:<a rel=next accesskey=n href="#Changing%20Block%20Size">Changing Block Size</a>,
-Previous:<a rel=previous accesskey=p href="#Malloc%20Examples">Malloc Examples</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Freeing after Malloc">Freeing after Malloc</a>,
+Next:<a rel=next accesskey=n href="#Changing Block Size">Changing Block Size</a>,
+Previous:<a rel=previous accesskey=p href="#Malloc Examples">Malloc Examples</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Freeing Memory Allocated with <code>malloc</code></h5>
 
@@ -5481,31 +5307,29 @@
 function <code>free</code> to make the block available to be allocated again. 
 The prototype for this function is in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>free</b><i> (void *<var>ptr</var>)
-</i></td>
+<td align="left"><code>void <b>free</b><i> (void *<var>ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>free</code> function deallocates the block of memory pointed at
 by <var>ptr</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>cfree</b><i> (void *<var>ptr</var>)
-</i></td>
+<td align="left"><code>void <b>cfree</b><i> (void *<var>ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function does the same thing as <code>free</code>.  It's provided for
 backward compatibility with SunOS; you should use <code>free</code> instead. 
 </td></tr>
@@ -5546,12 +5370,12 @@
 of the program's space is given back to the system when the process
 terminates.
 
 <p><hr>
-Node:<a name="Changing%20Block%20Size">Changing Block Size</a>,
-Next:<a rel=next accesskey=n href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>,
-Previous:<a rel=previous accesskey=p href="#Freeing%20after%20Malloc">Freeing after Malloc</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Changing Block Size">Changing Block Size</a>,
+Next:<a rel=next accesskey=n href="#Allocating Cleared Space">Allocating Cleared Space</a>,
+Previous:<a rel=previous accesskey=p href="#Freeing after Malloc">Freeing after Malloc</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Changing the Size of a Block</h5>
 
@@ -5564,16 +5388,15 @@
 <p>You can make the block longer by calling <code>realloc</code>.  This function
 is declared in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>realloc</b><i> (void *<var>ptr</var>, size_t <var>newsize</var>)
-</i></td>
+<td align="left"><code>void * <b>realloc</b><i> (void *<var>ptr</var>, size_t <var>newsize</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>realloc</code> function changes the size of the block whose address is
 <var>ptr</var> to be <var>newsize</var>.
 
@@ -5621,28 +5444,27 @@
 <p>If the new size you specify is the same as the old size, <code>realloc</code>
 is guaranteed to change nothing and return the same address that you gave.
 
 <p><hr>
-Node:<a name="Allocating%20Cleared%20Space">Allocating Cleared Space</a>,
-Next:<a rel=next accesskey=n href="#Efficiency%20and%20Malloc">Efficiency and Malloc</a>,
-Previous:<a rel=previous accesskey=p href="#Changing%20Block%20Size">Changing Block Size</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Allocating Cleared Space">Allocating Cleared Space</a>,
+Next:<a rel=next accesskey=n href="#Efficiency and Malloc">Efficiency and Malloc</a>,
+Previous:<a rel=previous accesskey=p href="#Changing Block Size">Changing Block Size</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Allocating Cleared Space</h5>
 
 <p>The function <code>calloc</code> allocates memory and clears it to zero.  It
 is declared in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>calloc</b><i> (size_t <var>count</var>, size_t <var>eltsize</var>)
-</i></td>
+<td align="left"><code>void * <b>calloc</b><i> (size_t <var>count</var>, size_t <var>eltsize</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function allocates a block long enough to contain a vector of
 <var>count</var> elements, each of size <var>eltsize</var>.  Its contents are
 cleared to zero before <code>calloc</code> returns. 
@@ -5667,12 +5489,12 @@
 <code>malloc</code>/<code>realloc</code>/<code>free</code> outside the C library, it
 should always define <code>calloc</code>, too.
 
 <p><hr>
-Node:<a name="Efficiency%20and%20Malloc">Efficiency and Malloc</a>,
-Next:<a rel=next accesskey=n href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>,
-Previous:<a rel=previous accesskey=p href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Efficiency and Malloc">Efficiency and Malloc</a>,
+Next:<a rel=next accesskey=n href="#Aligned Memory Blocks">Aligned Memory Blocks</a>,
+Previous:<a rel=previous accesskey=p href="#Allocating Cleared Space">Allocating Cleared Space</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Efficiency Considerations for <code>malloc</code></h5>
 
@@ -5692,12 +5514,12 @@
 <code>mmap</code> to be used can be adjusted with <code>mallopt</code>.  The use of
 <code>mmap</code> can also be disabled completely.
 
 <p><hr>
-Node:<a name="Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>,
-Next:<a rel=next accesskey=n href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>,
-Previous:<a rel=previous accesskey=p href="#Efficiency%20and%20Malloc">Efficiency and Malloc</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Aligned Memory Blocks">Aligned Memory Blocks</a>,
+Next:<a rel=next accesskey=n href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>,
+Previous:<a rel=previous accesskey=p href="#Efficiency and Malloc">Efficiency and Malloc</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Allocating Aligned Memory Blocks</h5>
 
@@ -5712,16 +5534,15 @@
 does not work in BSD, however--BSD does not provide any way to free
 such blocks.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memalign</b><i> (size_t <var>boundary</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>memalign</b><i> (size_t <var>boundary</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>memalign</code> function allocates a block of <var>size</var> bytes whose
 address is a multiple of <var>boundary</var>.  The <var>boundary</var> must be a
 power of two!  The function <code>memalign</code> works by allocating a
@@ -5730,16 +5551,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>posix_memalign</b><i> (void **<var>memptr</var>, size_t <var>alignment</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>posix_memalign</b><i> (void **<var>memptr</var>, size_t <var>alignment</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>posix_memalign</code> function is similar to the <code>memalign</code>
 function in that it returns a buffer of <var>size</var> bytes aligned to a
 multiple of <var>alignment</var>.  But it adds one requirement to the
@@ -5754,16 +5574,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>valloc</b><i> (size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>valloc</b><i> (size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Using <code>valloc</code> is like using <code>memalign</code> and passing the page size
 as the value of the second argument.  It is implemented like this:
 
@@ -5773,18 +5592,18 @@
   return memalign (getpagesize (), size);
 }
 </pre>
 
-<a href="#Query%20Memory%20Parameters">Query Memory Parameters</a> for more information about the memory
+<a href="#Query Memory Parameters">Query Memory Parameters</a> for more information about the memory
 subsystem. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>,
-Next:<a rel=next accesskey=n href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>,
-Previous:<a rel=previous accesskey=p href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Malloc Tunable Parameters">Malloc Tunable Parameters</a>,
+Next:<a rel=next accesskey=n href="#Heap Consistency Checking">Heap Consistency Checking</a>,
+Previous:<a rel=previous accesskey=p href="#Aligned Memory Blocks">Aligned Memory Blocks</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Malloc Tunable Parameters</h5>
 
@@ -5792,16 +5611,15 @@
 <code>mallopt</code> function.  This function is the general SVID/XPG
 interface, defined in <code>malloc.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mallopt</b><i> (int <var>param</var>, int <var>value</var>)
-</i></td>
+<td align="left"><code>int <b>mallopt</b><i> (int <var>param</var>, int <var>value</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 When calling <code>mallopt</code>, the <var>param</var> argument specifies the
 parameter to be set, and <var>value</var> the new value to be set.  Possible
 choices for <var>param</var>, as defined in <code>malloc.h</code>, are:
@@ -5830,12 +5648,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Heap%20Consistency%20Checking">Heap Consistency Checking</a>,
-Next:<a rel=next accesskey=n href="#Hooks%20for%20Malloc">Hooks for Malloc</a>,
-Previous:<a rel=previous accesskey=p href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Heap Consistency Checking">Heap Consistency Checking</a>,
+Next:<a rel=next accesskey=n href="#Hooks for Malloc">Hooks for Malloc</a>,
+Previous:<a rel=previous accesskey=p href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Heap Consistency Checking</h5>
 
@@ -5843,25 +5661,24 @@
 using the <code>mcheck</code> function.  This function is a GNU extension,
 declared in <code>mcheck.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mcheck</b><i> (void (*<var>abortfn</var>) (enum mcheck_status <var>status</var>))
-</i></td>
+<td align="left"><code>int <b>mcheck</b><i> (void (*<var>abortfn</var>) (enum mcheck_status <var>status</var>))</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Calling <code>mcheck</code> tells <code>malloc</code> to perform occasional
 consistency checks.  These will catch things such as writing
 past the end of a block that was allocated with <code>malloc</code>.
 
 <p>The <var>abortfn</var> argument is the function to call when an inconsistency
 is found.  If you supply a null pointer, then <code>mcheck</code> uses a
 default function which prints a message and calls <code>abort</code>
-(see <a href="#Aborting%20a%20Program">Aborting a Program</a>).  The function you supply is called with
+(see <a href="#Aborting a Program">Aborting a Program</a>).  The function you supply is called with
 one argument, which says what sort of inconsistency was detected; its
 type is described below.
 
 <p>It is too late to begin allocation checking once you have allocated
@@ -5894,16 +5711,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">enum mcheck_status <b>mprobe</b><i> (void *<var>pointer</var>)
-</i></td>
+<td align="left"><code>enum mcheck_status <b>mprobe</b><i> (void *<var>pointer</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mprobe</code> function lets you explicitly check for inconsistencies
 in a particular allocated block.  You must have already called
 <code>mcheck</code> at the beginning of the program, to do its occasional
@@ -5916,16 +5732,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>enum mcheck_status</b><i>
-</i></td>
+<td align="left"><code><b>enum mcheck_status</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This enumerated type describes what kind of inconsistency was detected
 in an allocated block, if any.  Here are the possible values:
 
@@ -5978,12 +5793,12 @@
 uncover the same bugs - but using <code>MALLOC_CHECK_</code> you don't need to
 recompile your application.
 
 <p><hr>
-Node:<a name="Hooks%20for%20Malloc">Hooks for Malloc</a>,
-Next:<a rel=next accesskey=n href="#Statistics%20of%20Malloc">Statistics of Malloc</a>,
-Previous:<a rel=previous accesskey=p href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Hooks for Malloc">Hooks for Malloc</a>,
+Next:<a rel=next accesskey=n href="#Statistics of Malloc">Statistics of Malloc</a>,
+Previous:<a rel=previous accesskey=p href="#Heap Consistency Checking">Heap Consistency Checking</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Memory Allocation Hooks</h5>
 
@@ -5994,16 +5809,15 @@
 
 <p>The hook variables are declared in <code>malloc.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__malloc_hook</b><i>
-</i></td>
+<td align="left"><code><b>__malloc_hook</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this variable is a pointer to the function that
 <code>malloc</code> uses whenever it is called.  You should define this
 function to look like <code>malloc</code>; that is, like:
@@ -6017,16 +5831,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__realloc_hook</b><i>
-</i></td>
+<td align="left"><code><b>__realloc_hook</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this variable is a pointer to function that <code>realloc</code>
 uses whenever it is called.  You should define this function to look
 like <code>realloc</code>; that is, like:
@@ -6040,16 +5853,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__free_hook</b><i>
-</i></td>
+<td align="left"><code><b>__free_hook</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this variable is a pointer to function that <code>free</code>
 uses whenever it is called.  You should define this function to look
 like <code>free</code>; that is, like:
@@ -6063,16 +5875,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__memalign_hook</b><i>
-</i></td>
+<td align="left"><code><b>__memalign_hook</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this variable is a pointer to function that <code>memalign</code>
 uses whenever it is called.  You should define this function to look
 like <code>memalign</code>; that is, like:
@@ -6094,16 +5905,15 @@
 coming back from the recursive call, all the hooks should be resaved
 since a hook might modify itself.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__malloc_initialize_hook</b><i>
-</i></td>
+<td align="left"><code><b>__malloc_initialize_hook</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this variable is a pointer to a function that is called
 once when the malloc implementation is initialized.  This is a weak
 variable, so it can be overridden in the application with a definition
@@ -6198,16 +6008,16 @@
   ...
 }
 </pre>
 
-<p>The <code>mcheck</code> function (see <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>) works by
+<p>The <code>mcheck</code> function (see <a href="#Heap Consistency Checking">Heap Consistency Checking</a>) works by
 installing such hooks.
 
 <p><hr>
-Node:<a name="Statistics%20of%20Malloc">Statistics of Malloc</a>,
-Next:<a rel=next accesskey=n href="#Summary%20of%20Malloc">Summary of Malloc</a>,
-Previous:<a rel=previous accesskey=p href="#Hooks%20for%20Malloc">Hooks for Malloc</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Statistics of Malloc">Statistics of Malloc</a>,
+Next:<a rel=next accesskey=n href="#Summary of Malloc">Summary of Malloc</a>,
+Previous:<a rel=previous accesskey=p href="#Hooks for Malloc">Hooks for Malloc</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Statistics for Memory Allocation with <code>malloc</code></h5>
 
@@ -6216,16 +6026,15 @@
 are declared in <code>malloc.h</code>; they are an extension of the standard
 SVID/XPG version.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct mallinfo</b><i>
-</i></td>
+<td align="left"><code><b>struct mallinfo</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure type is used to return information about the dynamic
 memory allocator.  It contains the following members:
 
@@ -6237,9 +6046,9 @@
 <br><dt><code>int ordblks</code>
 <dd>This is the number of chunks not in use.  (The memory allocator
 internally gets chunks of memory from the operating system, and then
 carves them up to satisfy individual <code>malloc</code> requests; see
-<a href="#Efficiency%20and%20Malloc">Efficiency and Malloc</a>.)
+<a href="#Efficiency and Malloc">Efficiency and Malloc</a>.)
 
 <br><dt><code>int smblks</code>
 <dd>This field is unused.
 
@@ -6271,62 +6080,61 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct mallinfo <b>mallinfo</b><i> (void)
-</i></td>
+<td align="left"><code>struct mallinfo <b>mallinfo</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns information about the current dynamic memory usage
 in a structure of type <code>struct mallinfo</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Summary%20of%20Malloc">Summary of Malloc</a>,
-Previous:<a rel=previous accesskey=p href="#Statistics%20of%20Malloc">Statistics of Malloc</a>,
-Up:<a rel=up accesskey=u href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+Node:<a name="Summary of Malloc">Summary of Malloc</a>,
+Previous:<a rel=previous accesskey=p href="#Statistics of Malloc">Statistics of Malloc</a>,
+Up:<a rel=up accesskey=u href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <br>
 
 <h5>Summary of <code>malloc</code>-Related Functions</h5>
 
 <p>Here is a summary of the functions that work with <code>malloc</code>:
 
 <dl>
 <dt><code>void *malloc (size_t <var>size</var>)</code>
-<dd>Allocate a block of <var>size</var> bytes.  See <a href="#Basic%20Allocation">Basic Allocation</a>.
+<dd>Allocate a block of <var>size</var> bytes.  See <a href="#Basic Allocation">Basic Allocation</a>.
 
 <br><dt><code>void free (void *<var>addr</var>)</code>
-<dd>Free a block previously allocated by <code>malloc</code>.  See <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>.
+<dd>Free a block previously allocated by <code>malloc</code>.  See <a href="#Freeing after Malloc">Freeing after Malloc</a>.
 
 <br><dt><code>void *realloc (void *<var>addr</var>, size_t <var>size</var>)</code>
 <dd>Make a block previously allocated by <code>malloc</code> larger or smaller,
-possibly by copying it to a new location.  See <a href="#Changing%20Block%20Size">Changing Block Size</a>.
+possibly by copying it to a new location.  See <a href="#Changing Block Size">Changing Block Size</a>.
 
 <br><dt><code>void *calloc (size_t <var>count</var>, size_t <var>eltsize</var>)</code>
 <dd>Allocate a block of <var>count</var> * <var>eltsize</var> bytes using
-<code>malloc</code>, and set its contents to zero.  See <a href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>.
+<code>malloc</code>, and set its contents to zero.  See <a href="#Allocating Cleared Space">Allocating Cleared Space</a>.
 
 <br><dt><code>void *valloc (size_t <var>size</var>)</code>
 <dd>Allocate a block of <var>size</var> bytes, starting on a page boundary. 
-See <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>.
+See <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>.
 
 <br><dt><code>void *memalign (size_t <var>size</var>, size_t <var>boundary</var>)</code>
 <dd>Allocate a block of <var>size</var> bytes, starting on an address that is a
-multiple of <var>boundary</var>.  See <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>.
+multiple of <var>boundary</var>.  See <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>.
 
 <br><dt><code>int mallopt (int <var>param</var>, int <var>value</var>)</code>
-<dd>Adjust a tunable parameter.  See <a href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>.
+<dd>Adjust a tunable parameter.  See <a href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>.
 
 <br><dt><code>int mcheck (void (*<var>abortfn</var>) (void))</code>
 <dd>Tell <code>malloc</code> to perform occasional consistency checks on
 dynamically allocated memory, and to call <var>abortfn</var> when an
-inconsistency is found.  See <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>.
+inconsistency is found.  See <a href="#Heap Consistency Checking">Heap Consistency Checking</a>.
 
 <br><dt><code>void *(*__malloc_hook) (size_t <var>size</var>, const void *<var>caller</var>)</code>
 <dd>A pointer to a function that <code>malloc</code> uses whenever it is called.
 
@@ -6340,16 +6148,16 @@
 <dd>A pointer to a function that <code>memalign</code> uses whenever it is called.
 
 <br><dt><code>struct mallinfo mallinfo (void)</code>
 <dd>Return information about the current dynamic memory usage. 
-See <a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>. 
+See <a href="#Statistics of Malloc">Statistics of Malloc</a>. 
 </dl>
 
 <p><hr>
-Node:<a name="Allocation%20Debugging">Allocation Debugging</a>,
+Node:<a name="Allocation Debugging">Allocation Debugging</a>,
 Next:<a rel=next accesskey=n href="#Obstacks">Obstacks</a>,
-Previous:<a rel=previous accesskey=p href="#Unconstrained%20Allocation">Unconstrained Allocation</a>,
-Up:<a rel=up accesskey=u href="#Memory%20Allocation">Memory Allocation</a>
+Previous:<a rel=previous accesskey=p href="#Unconstrained Allocation">Unconstrained Allocation</a>,
+Up:<a rel=up accesskey=u href="#Memory Allocation">Memory Allocation</a>
 <br>
 
 <h4>Allocation Debugging</h4>
 
@@ -6365,31 +6173,30 @@
 mode which is enabled by an environment variable.  There are no speed
 penalties for the program if the debugging mode is not enabled.
 
 <ul>
-<li><a accesskey=1 href="#Tracing%20malloc">Tracing malloc</a>:                How to install the tracing functionality. 
-<li><a accesskey=2 href="#Using%20the%20Memory%20Debugger">Using the Memory Debugger</a>:     Example programs excerpts. 
-<li><a accesskey=3 href="#Tips%20for%20the%20Memory%20Debugger">Tips for the Memory Debugger</a>:  Some more or less clever ideas. 
-<li><a accesskey=4 href="#Interpreting%20the%20traces">Interpreting the traces</a>:       What do all these lines mean? 
+<li><a accesskey=1 href="#Tracing malloc">Tracing malloc</a>:                How to install the tracing functionality. 
+<li><a accesskey=2 href="#Using the Memory Debugger">Using the Memory Debugger</a>:     Example programs excerpts. 
+<li><a accesskey=3 href="#Tips for the Memory Debugger">Tips for the Memory Debugger</a>:  Some more or less clever ideas. 
+<li><a accesskey=4 href="#Interpreting the traces">Interpreting the traces</a>:       What do all these lines mean? 
 </ul>
 
 <p><hr>
-Node:<a name="Tracing%20malloc">Tracing malloc</a>,
-Next:<a rel=next accesskey=n href="#Using%20the%20Memory%20Debugger">Using the Memory Debugger</a>,
-Up:<a rel=up accesskey=u href="#Allocation%20Debugging">Allocation Debugging</a>
+Node:<a name="Tracing malloc">Tracing malloc</a>,
+Next:<a rel=next accesskey=n href="#Using the Memory Debugger">Using the Memory Debugger</a>,
+Up:<a rel=up accesskey=u href="#Allocation Debugging">Allocation Debugging</a>
 <br>
 
 <h5>How to install the tracing functionality</h5>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>mtrace</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>mtrace</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 When the <code>mtrace</code> function is called it looks for an environment
 variable named <code>MALLOC_TRACE</code>.  This variable is supposed to
 contain a valid file name.  The user must have write access.  If the
@@ -6400,9 +6207,9 @@
 with the SUID or SGID bit set.
 
 <p>If the named file is successfully opened, <code>mtrace</code> installs special
 handlers for the functions <code>malloc</code>, <code>realloc</code>, and
-<code>free</code> (see <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>).  From then on, all uses of these
+<code>free</code> (see <a href="#Hooks for Malloc">Hooks for Malloc</a>).  From then on, all uses of these
 functions are traced and protocolled into the file.  There is now of
 course a speed penalty for all calls to the traced functions so tracing
 should not be enabled during normal use.
 
@@ -6411,16 +6218,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>muntrace</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>muntrace</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>muntrace</code> function can be called after <code>mtrace</code> was used
 to enable tracing the <code>malloc</code> calls.  If no (successful) call of
 <code>mtrace</code> was made <code>muntrace</code> does nothing.
@@ -6434,12 +6240,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Using%20the%20Memory%20Debugger">Using the Memory Debugger</a>,
-Next:<a rel=next accesskey=n href="#Tips%20for%20the%20Memory%20Debugger">Tips for the Memory Debugger</a>,
-Previous:<a rel=previous accesskey=p href="#Tracing%20malloc">Tracing malloc</a>,
-Up:<a rel=up accesskey=u href="#Allocation%20Debugging">Allocation Debugging</a>
+Node:<a name="Using the Memory Debugger">Using the Memory Debugger</a>,
+Next:<a rel=next accesskey=n href="#Tips for the Memory Debugger">Tips for the Memory Debugger</a>,
+Previous:<a rel=previous accesskey=p href="#Tracing malloc">Tracing malloc</a>,
+Up:<a rel=up accesskey=u href="#Allocation Debugging">Allocation Debugging</a>
 <br>
 
 <h5>Example program excerpts</h5>
 
@@ -6484,12 +6290,12 @@
 calls which are executed by constructors of the program or used
 libraries).
 
 <p><hr>
-Node:<a name="Tips%20for%20the%20Memory%20Debugger">Tips for the Memory Debugger</a>,
-Next:<a rel=next accesskey=n href="#Interpreting%20the%20traces">Interpreting the traces</a>,
-Previous:<a rel=previous accesskey=p href="#Using%20the%20Memory%20Debugger">Using the Memory Debugger</a>,
-Up:<a rel=up accesskey=u href="#Allocation%20Debugging">Allocation Debugging</a>
+Node:<a name="Tips for the Memory Debugger">Tips for the Memory Debugger</a>,
+Next:<a rel=next accesskey=n href="#Interpreting the traces">Interpreting the traces</a>,
+Previous:<a rel=previous accesskey=p href="#Using the Memory Debugger">Using the Memory Debugger</a>,
+Up:<a rel=up accesskey=u href="#Allocation Debugging">Allocation Debugging</a>
 <br>
 
 <h5>Some more or less clever ideas</h5>
 
@@ -6535,11 +6341,11 @@
 the first signal but if there is a memory leak this will show up
 nevertheless.
 
 <p><hr>
-Node:<a name="Interpreting%20the%20traces">Interpreting the traces</a>,
-Previous:<a rel=previous accesskey=p href="#Tips%20for%20the%20Memory%20Debugger">Tips for the Memory Debugger</a>,
-Up:<a rel=up accesskey=u href="#Allocation%20Debugging">Allocation Debugging</a>
+Node:<a name="Interpreting the traces">Interpreting the traces</a>,
+Previous:<a rel=previous accesskey=p href="#Tips for the Memory Debugger">Tips for the Memory Debugger</a>,
+Up:<a rel=up accesskey=u href="#Allocation Debugging">Allocation Debugging</a>
 <br>
 
 <h5>Interpreting the traces</h5>
 
@@ -6629,11 +6435,11 @@
 Whether this is a real problem remains to be investigated.
 
 <p><hr>
 Node:<a name="Obstacks">Obstacks</a>,
-Next:<a rel=next accesskey=n href="#Variable%20Size%20Automatic">Variable Size Automatic</a>,
-Previous:<a rel=previous accesskey=p href="#Allocation%20Debugging">Allocation Debugging</a>,
-Up:<a rel=up accesskey=u href="#Memory%20Allocation">Memory Allocation</a>
+Next:<a rel=next accesskey=n href="#Variable Size Automatic">Variable Size Automatic</a>,
+Previous:<a rel=previous accesskey=p href="#Allocation Debugging">Allocation Debugging</a>,
+Up:<a rel=up accesskey=u href="#Memory Allocation">Memory Allocation</a>
 <br>
 
 <h4>Obstacks</h4>
 
@@ -6649,28 +6455,28 @@
 the objects are usually small.  And the only space overhead per object is
 the padding needed to start each object on a suitable boundary.
 
 <ul>
-<li><a accesskey=1 href="#Creating%20Obstacks">Creating Obstacks</a>: 		How to declare an obstack in your program. 
-<li><a accesskey=2 href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>: 	Preparations needed before you can
+<li><a accesskey=1 href="#Creating Obstacks">Creating Obstacks</a>: 		How to declare an obstack in your program. 
+<li><a accesskey=2 href="#Preparing for Obstacks">Preparing for Obstacks</a>: 	Preparations needed before you can
 				 use obstacks. 
-<li><a accesskey=3 href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>:     Allocating objects in an obstack. 
-<li><a accesskey=4 href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>:      Freeing objects in an obstack. 
-<li><a accesskey=5 href="#Obstack%20Functions">Obstack Functions</a>: 		The obstack functions are both
+<li><a accesskey=3 href="#Allocation in an Obstack">Allocation in an Obstack</a>:     Allocating objects in an obstack. 
+<li><a accesskey=4 href="#Freeing Obstack Objects">Freeing Obstack Objects</a>:      Freeing objects in an obstack. 
+<li><a accesskey=5 href="#Obstack Functions">Obstack Functions</a>: 		The obstack functions are both
 				 functions and macros. 
-<li><a accesskey=6 href="#Growing%20Objects">Growing Objects</a>:              Making an object bigger by stages. 
-<li><a accesskey=7 href="#Extra%20Fast%20Growing">Extra Fast Growing</a>: 		Extra-high-efficiency (though more
+<li><a accesskey=6 href="#Growing Objects">Growing Objects</a>:              Making an object bigger by stages. 
+<li><a accesskey=7 href="#Extra Fast Growing">Extra Fast Growing</a>: 		Extra-high-efficiency (though more
 				 complicated) growing objects. 
-<li><a accesskey=8 href="#Status%20of%20an%20Obstack">Status of an Obstack</a>:         Inquiries about the status of an obstack. 
-<li><a accesskey=9 href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>:      Controlling alignment of objects in obstacks. 
-<li><a href="#Obstack%20Chunks">Obstack Chunks</a>:               How obstacks obtain and release chunks;
+<li><a accesskey=8 href="#Status of an Obstack">Status of an Obstack</a>:         Inquiries about the status of an obstack. 
+<li><a accesskey=9 href="#Obstacks Data Alignment">Obstacks Data Alignment</a>:      Controlling alignment of objects in obstacks. 
+<li><a href="#Obstack Chunks">Obstack Chunks</a>:               How obstacks obtain and release chunks;
 				 efficiency considerations. 
-<li><a href="#Summary%20of%20Obstacks">Summary of Obstacks</a>: 
+<li><a href="#Summary of Obstacks">Summary of Obstacks</a>: 
 </ul>
 
 <p><hr>
-Node:<a name="Creating%20Obstacks">Creating Obstacks</a>,
-Next:<a rel=next accesskey=n href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>,
+Node:<a name="Creating Obstacks">Creating Obstacks</a>,
+Next:<a rel=next accesskey=n href="#Preparing for Obstacks">Preparing for Obstacks</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Creating Obstacks</h5>
@@ -6678,16 +6484,15 @@
 <p>The utilities for manipulating obstacks are declared in the header
 file <code>obstack.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct obstack</b><i>
-</i></td>
+<td align="left"><code><b>struct obstack</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An obstack is represented by a data structure of type <code>struct
 obstack</code>.  This structure has a small fixed size; it records the status
 of the obstack and how to find the space in which objects are allocated. 
@@ -6720,11 +6525,11 @@
 directly or indirectly.  You must also supply a function to free a chunk. 
 These matters are described in the following section.
 
 <p><hr>
-Node:<a name="Preparing%20for%20Obstacks">Preparing for Obstacks</a>,
-Next:<a rel=next accesskey=n href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>,
-Previous:<a rel=previous accesskey=p href="#Creating%20Obstacks">Creating Obstacks</a>,
+Node:<a name="Preparing for Obstacks">Preparing for Obstacks</a>,
+Next:<a rel=next accesskey=n href="#Allocation in an Obstack">Allocation in an Obstack</a>,
+Previous:<a rel=previous accesskey=p href="#Creating Obstacks">Creating Obstacks</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Preparing for Using Obstacks</h5>
@@ -6743,32 +6548,31 @@
 them are freed.  These macros should appear before any use of obstacks
 in the source file.
 
 <p>Usually these are defined to use <code>malloc</code> via the intermediary
-<code>xmalloc</code> (see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>).  This is done with
+<code>xmalloc</code> (see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>).  This is done with
 the following pair of macro definitions:
 
 <br><pre>#define obstack_chunk_alloc xmalloc
 #define obstack_chunk_free free
 </pre>
 
 <p>Though the memory you get using obstacks really comes from <code>malloc</code>,
 using obstacks is faster because <code>malloc</code> is called less often, for
-larger blocks of memory.  See <a href="#Obstack%20Chunks">Obstack Chunks</a>, for full details.
+larger blocks of memory.  See <a href="#Obstack Chunks">Obstack Chunks</a>, for full details.
 
 <p>At run time, before the program can use a <code>struct obstack</code> object
 as an obstack, it must initialize the obstack by calling
 <code>obstack_init</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_init</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>obstack_init</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Initialize obstack <var>obstack-ptr</var> for allocation of objects.  This
 function calls the obstack's <code>obstack_chunk_alloc</code> function.  If
 allocation of memory fails, the function pointed to by
@@ -6794,22 +6598,21 @@
 obstack_init (myobstack_ptr);
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>obstack_alloc_failed_handler</b><i>
-</i></td>
+<td align="left"><code><b>obstack_alloc_failed_handler</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this variable is a pointer to a function that
 <code>obstack</code> uses when <code>obstack_chunk_alloc</code> fails to allocate
 memory.  The default action is to print a message and abort. 
 You should supply a function that either calls <code>exit</code>
-(see <a href="#Program%20Termination">Program Termination</a>) or <code>longjmp</code> (see <a href="#Non-Local%20Exits">Non-Local Exits</a>) and doesn't return.
+(see <a href="#Program Termination">Program Termination</a>) or <code>longjmp</code> (see <a href="#Non-Local Exits">Non-Local Exits</a>) and doesn't return.
 
 <br><pre>void my_obstack_alloc_failed (void)
 <small>...</small>
 obstack_alloc_failed_handler = &amp;my_obstack_alloc_failed;
@@ -6818,11 +6621,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>,
-Next:<a rel=next accesskey=n href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>,
-Previous:<a rel=previous accesskey=p href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>,
+Node:<a name="Allocation in an Obstack">Allocation in an Obstack</a>,
+Next:<a rel=next accesskey=n href="#Freeing Obstack Objects">Freeing Obstack Objects</a>,
+Previous:<a rel=previous accesskey=p href="#Preparing for Obstacks">Preparing for Obstacks</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Allocation in an Obstack</h5>
@@ -6830,16 +6633,15 @@
 <p>The most direct way to allocate an object in an obstack is with
 <code>obstack_alloc</code>, which is invoked almost like <code>malloc</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>obstack_alloc</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>obstack_alloc</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This allocates an uninitialized block of <var>size</var> bytes in an obstack
 and returns its address.  Here <var>obstack-ptr</var> specifies which obstack
 to allocate the block in; it is the address of the <code>struct obstack</code>
@@ -6871,16 +6673,15 @@
 <p>To allocate a block with specified contents, use the function
 <code>obstack_copy</code>, declared like this:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>obstack_copy</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>obstack_copy</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This allocates a block and initializes it by copying <var>size</var>
 bytes of data starting at <var>address</var>.  It calls
 <code>obstack_alloc_failed_handler</code> if allocation of memory by
@@ -6888,16 +6689,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>obstack_copy0</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>obstack_copy0</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Like <code>obstack_copy</code>, but appends an extra byte containing a null
 character.  This extra byte is not counted in the argument <var>size</var>. 
 </td></tr>
@@ -6914,14 +6714,14 @@
 }
 </pre>
 
 <p>Contrast this with the previous example of <code>savestring</code> using
-<code>malloc</code> (see <a href="#Basic%20Allocation">Basic Allocation</a>).
+<code>malloc</code> (see <a href="#Basic Allocation">Basic Allocation</a>).
 
 <p><hr>
-Node:<a name="Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>,
-Next:<a rel=next accesskey=n href="#Obstack%20Functions">Obstack Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>,
+Node:<a name="Freeing Obstack Objects">Freeing Obstack Objects</a>,
+Next:<a rel=next accesskey=n href="#Obstack Functions">Obstack Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Allocation in an Obstack">Allocation in an Obstack</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Freeing Objects in an Obstack</h5>
@@ -6931,16 +6731,15 @@
 one object automatically frees all other objects allocated more recently
 in the same obstack.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_free</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>object</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_free</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>object</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>object</var> is a null pointer, everything allocated in the obstack
 is freed.  Otherwise, <var>object</var> must be the address of an object
 allocated in the obstack.  Then <var>object</var> is freed, along with
@@ -6957,15 +6756,15 @@
 </pre>
 
 <p>Recall that the objects in an obstack are grouped into chunks.  When all
 the objects in a chunk become free, the obstack library automatically
-frees the chunk (see <a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>).  Then other
+frees the chunk (see <a href="#Preparing for Obstacks">Preparing for Obstacks</a>).  Then other
 obstacks, or non-obstack allocation, can reuse the space of the chunk.
 
 <p><hr>
-Node:<a name="Obstack%20Functions">Obstack Functions</a>,
-Next:<a rel=next accesskey=n href="#Growing%20Objects">Growing Objects</a>,
-Previous:<a rel=previous accesskey=p href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>,
+Node:<a name="Obstack Functions">Obstack Functions</a>,
+Next:<a rel=next accesskey=n href="#Growing Objects">Growing Objects</a>,
+Previous:<a rel=previous accesskey=p href="#Freeing Obstack Objects">Freeing Obstack Objects</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Obstack Functions and Macros</h5>
@@ -7008,9 +6807,9 @@
 funcp = obstack_alloc;
 </pre>
 
 <p>This is the same situation that exists in ISO&nbsp;C for the standard library
-functions.  See <a href="#Macro%20Definitions">Macro Definitions</a>.
+functions.  See <a href="#Macro Definitions">Macro Definitions</a>.
 
 <p><strong>Warning:</strong> When you do use the macros, you must observe the
 precaution of avoiding side effects in the first operand, even in ISO&nbsp;C.
 
@@ -7018,11 +6817,11 @@
 various language extensions in GNU C permit defining the macros so as to
 compute each argument only once.
 
 <p><hr>
-Node:<a name="Growing%20Objects">Growing Objects</a>,
-Next:<a rel=next accesskey=n href="#Extra%20Fast%20Growing">Extra Fast Growing</a>,
-Previous:<a rel=previous accesskey=p href="#Obstack%20Functions">Obstack Functions</a>,
+Node:<a name="Growing Objects">Growing Objects</a>,
+Next:<a rel=next accesskey=n href="#Extra Fast Growing">Extra Fast Growing</a>,
+Previous:<a rel=previous accesskey=p href="#Obstack Functions">Obstack Functions</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Growing Objects</h5>
@@ -7047,31 +6846,29 @@
 ordinary allocation of another object.  If you try to do so, the space
 already added to the growing object will become part of the other object.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_blank</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_blank</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The most basic function for adding to a growing object is
 <code>obstack_blank</code>, which adds space without initializing it. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_grow</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_grow</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 To add a block of initialized space, use <code>obstack_grow</code>, which is
 the growing-object analogue of <code>obstack_copy</code>.  It adds <var>size</var>
 bytes of data to the growing object, copying the contents from
@@ -7079,88 +6876,83 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_grow0</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_grow0</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the growing-object analogue of <code>obstack_copy0</code>.  It adds
 <var>size</var> bytes copied from <var>data</var>, followed by an additional null
 character. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_1grow</b><i> (struct obstack *<var>obstack-ptr</var>, char <var>c</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_1grow</b><i> (struct obstack *<var>obstack-ptr</var>, char <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 To add one character at a time, use the function <code>obstack_1grow</code>. 
 It adds a single byte containing <var>c</var> to the growing object. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_ptr_grow</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_ptr_grow</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Adding the value of a pointer one can use the function
 <code>obstack_ptr_grow</code>.  It adds <code>sizeof (void *)</code> bytes
 containing the value of <var>data</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_int_grow</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>data</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_int_grow</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>data</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A single value of type <code>int</code> can be added by using the
 <code>obstack_int_grow</code> function.  It adds <code>sizeof (int)</code> bytes to
 the growing object and initializes them with the value of <var>data</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>obstack_finish</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>void * <b>obstack_finish</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 When you are finished growing the object, use the function
 <code>obstack_finish</code> to close it off and return its final address.
 
 <p>Once you have finished the object, the obstack is available for ordinary
 allocation or for growing another object.
 
 <p>This function can return a null pointer under the same conditions as
-<code>obstack_alloc</code> (see <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>). 
+<code>obstack_alloc</code> (see <a href="#Allocation in an Obstack">Allocation in an Obstack</a>). 
 </td></tr>
 </table>
 
 <p>When you build an object by growing it, you will probably need to know
@@ -7169,16 +6961,15 @@
 before finishing the object with the function <code>obstack_object_size</code>,
 declared as follows:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_object_size</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>obstack_object_size</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the current size of the growing object, in bytes. 
 Remember to call this function <em>before</em> finishing the object. 
 After it is finished, <code>obstack_object_size</code> will return zero. 
@@ -7197,11 +6988,11 @@
 the current object smaller.  Just don't try to shrink it beyond zero
 length--there's no telling what will happen if you do that.
 
 <p><hr>
-Node:<a name="Extra%20Fast%20Growing">Extra Fast Growing</a>,
-Next:<a rel=next accesskey=n href="#Status%20of%20an%20Obstack">Status of an Obstack</a>,
-Previous:<a rel=previous accesskey=p href="#Growing%20Objects">Growing Objects</a>,
+Node:<a name="Extra Fast Growing">Extra Fast Growing</a>,
+Next:<a rel=next accesskey=n href="#Status of an Obstack">Status of an Obstack</a>,
+Previous:<a rel=previous accesskey=p href="#Growing Objects">Growing Objects</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Extra Fast Growing Objects</h5>
@@ -7222,16 +7013,15 @@
 <p>The function <code>obstack_room</code> returns the amount of room available
 in the current chunk.  It is declared as follows:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_room</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>obstack_room</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This returns the number of bytes that can be added safely to the current
 growing object (or to an object about to be started) in obstack
 <var>obstack</var> using the fast growth functions. 
@@ -7241,63 +7031,59 @@
 <p>While you know there is room, you can use these fast growth functions
 for adding data to a growing object:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_1grow_fast</b><i> (struct obstack *<var>obstack-ptr</var>, char <var>c</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_1grow_fast</b><i> (struct obstack *<var>obstack-ptr</var>, char <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>obstack_1grow_fast</code> adds one byte containing the
 character <var>c</var> to the growing object in obstack <var>obstack-ptr</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_ptr_grow_fast</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_ptr_grow_fast</b><i> (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>obstack_ptr_grow_fast</code> adds <code>sizeof (void *)</code>
 bytes containing the value of <var>data</var> to the growing object in
 obstack <var>obstack-ptr</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_int_grow_fast</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>data</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_int_grow_fast</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>data</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>obstack_int_grow_fast</code> adds <code>sizeof (int)</code> bytes
 containing the value of <var>data</var> to the growing object in obstack
 <var>obstack-ptr</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>obstack_blank_fast</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>void <b>obstack_blank_fast</b><i> (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>obstack_blank_fast</code> adds <var>size</var> bytes to the
 growing object in obstack <var>obstack-ptr</var> without initializing them. 
 </td></tr>
@@ -7342,11 +7128,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Status%20of%20an%20Obstack">Status of an Obstack</a>,
-Next:<a rel=next accesskey=n href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>,
-Previous:<a rel=previous accesskey=p href="#Extra%20Fast%20Growing">Extra Fast Growing</a>,
+Node:<a name="Status of an Obstack">Status of an Obstack</a>,
+Next:<a rel=next accesskey=n href="#Obstacks Data Alignment">Obstacks Data Alignment</a>,
+Previous:<a rel=previous accesskey=p href="#Extra Fast Growing">Extra Fast Growing</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Status of an Obstack</h5>
@@ -7355,16 +7141,15 @@
 allocation in an obstack.  You can use them to learn about an object while
 still growing it.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>obstack_base</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>void * <b>obstack_base</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the tentative address of the beginning of the
 currently growing object in <var>obstack-ptr</var>.  If you finish the object
 immediately, it will have that address.  If you make it larger first, it
@@ -7376,16 +7161,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>obstack_next_free</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>void * <b>obstack_next_free</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the address of the first free byte in the current
 chunk of obstack <var>obstack-ptr</var>.  This is the end of the currently
 growing object.  If no object is growing, <code>obstack_next_free</code>
@@ -7393,16 +7177,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_object_size</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>obstack_object_size</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the size in bytes of the currently growing object. 
 This is equivalent to
 
@@ -7411,11 +7194,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>,
-Next:<a rel=next accesskey=n href="#Obstack%20Chunks">Obstack Chunks</a>,
-Previous:<a rel=previous accesskey=p href="#Status%20of%20an%20Obstack">Status of an Obstack</a>,
+Node:<a name="Obstacks Data Alignment">Obstacks Data Alignment</a>,
+Next:<a rel=next accesskey=n href="#Obstack Chunks">Obstack Chunks</a>,
+Previous:<a rel=previous accesskey=p href="#Status of an Obstack">Status of an Obstack</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Alignment of Data in Obstacks</h5>
@@ -7428,16 +7211,15 @@
 <code>obstack_alignment_mask</code>, whose function prototype looks like
 this:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_alignment_mask</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>obstack_alignment_mask</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value is a bit mask; a bit that is 1 indicates that the corresponding
 bit in the address of an object should be 0.  The mask value should be one
 less than a power of 2; the effect is that all object addresses are
@@ -7462,11 +7244,11 @@
 This will finish a zero-length object and then do proper alignment for
 the next object.
 
 <p><hr>
-Node:<a name="Obstack%20Chunks">Obstack Chunks</a>,
-Next:<a rel=next accesskey=n href="#Summary%20of%20Obstacks">Summary of Obstacks</a>,
-Previous:<a rel=previous accesskey=p href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>,
+Node:<a name="Obstack Chunks">Obstack Chunks</a>,
+Next:<a rel=next accesskey=n href="#Summary of Obstacks">Summary of Obstacks</a>,
+Previous:<a rel=previous accesskey=p href="#Obstacks Data Alignment">Obstacks Data Alignment</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Obstack Chunks</h5>
@@ -7484,9 +7266,9 @@
 library frees the chunk by calling <code>obstack_chunk_free</code>, which you
 must also define.
 
 <p>These two must be defined (as macros) or declared (as functions) in each
-source file that uses <code>obstack_init</code> (see <a href="#Creating%20Obstacks">Creating Obstacks</a>). 
+source file that uses <code>obstack_init</code> (see <a href="#Creating Obstacks">Creating Obstacks</a>). 
 Most often they are defined as macros like this:
 
 <br><pre>#define obstack_chunk_alloc malloc
 #define obstack_chunk_free free
@@ -7502,16 +7284,15 @@
 enough to satisfy many typical requests on the obstack yet short enough
 not to waste too much memory in the portion of the last chunk not yet used.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_chunk_size</b><i> (struct obstack *<var>obstack-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>obstack_chunk_size</b><i> (struct obstack *<var>obstack-ptr</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This returns the chunk size of the given obstack. 
 </td></tr>
 </table>
@@ -7528,10 +7309,10 @@
   obstack_chunk_size (obstack_ptr) = <var>new-chunk-size</var>;
 </pre>
 
 <p><hr>
-Node:<a name="Summary%20of%20Obstacks">Summary of Obstacks</a>,
-Previous:<a rel=previous accesskey=p href="#Obstack%20Chunks">Obstack Chunks</a>,
+Node:<a name="Summary of Obstacks">Summary of Obstacks</a>,
+Previous:<a rel=previous accesskey=p href="#Obstack Chunks">Obstack Chunks</a>,
 Up:<a rel=up accesskey=u href="#Obstacks">Obstacks</a>
 <br>
 
 <h5>Summary of Obstack Functions</h5>
@@ -7541,82 +7322,82 @@
 argument.
 
 <dl>
 <dt><code>void obstack_init (struct obstack *<var>obstack-ptr</var>)</code>
-<dd>Initialize use of an obstack.  See <a href="#Creating%20Obstacks">Creating Obstacks</a>.
+<dd>Initialize use of an obstack.  See <a href="#Creating Obstacks">Creating Obstacks</a>.
 
 <br><dt><code>void *obstack_alloc (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</code>
 <dd>Allocate an object of <var>size</var> uninitialized bytes. 
-See <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>.
+See <a href="#Allocation in an Obstack">Allocation in an Obstack</a>.
 
 <br><dt><code>void *obstack_copy (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</code>
 <dd>Allocate an object of <var>size</var> bytes, with contents copied from
-<var>address</var>.  See <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>.
+<var>address</var>.  See <a href="#Allocation in an Obstack">Allocation in an Obstack</a>.
 
 <br><dt><code>void *obstack_copy0 (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</code>
 <dd>Allocate an object of <var>size</var>+1 bytes, with <var>size</var> of them copied
 from <var>address</var>, followed by a null character at the end. 
-See <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>.
+See <a href="#Allocation in an Obstack">Allocation in an Obstack</a>.
 
 <br><dt><code>void obstack_free (struct obstack *<var>obstack-ptr</var>, void *<var>object</var>)</code>
 <dd>Free <var>object</var> (and everything allocated in the specified obstack
-more recently than <var>object</var>).  See <a href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>.
+more recently than <var>object</var>).  See <a href="#Freeing Obstack Objects">Freeing Obstack Objects</a>.
 
 <br><dt><code>void obstack_blank (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</code>
 <dd>Add <var>size</var> uninitialized bytes to a growing object. 
-See <a href="#Growing%20Objects">Growing Objects</a>.
+See <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_grow (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</code>
 <dd>Add <var>size</var> bytes, copied from <var>address</var>, to a growing object. 
-See <a href="#Growing%20Objects">Growing Objects</a>.
+See <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_grow0 (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</code>
 <dd>Add <var>size</var> bytes, copied from <var>address</var>, to a growing object,
-and then add another byte containing a null character.  See <a href="#Growing%20Objects">Growing Objects</a>.
+and then add another byte containing a null character.  See <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_1grow (struct obstack *<var>obstack-ptr</var>, char <var>data-char</var>)</code>
 <dd>Add one byte containing <var>data-char</var> to a growing object. 
-See <a href="#Growing%20Objects">Growing Objects</a>.
+See <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void *obstack_finish (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>Finalize the object that is growing and return its permanent address. 
-See <a href="#Growing%20Objects">Growing Objects</a>.
+See <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>int obstack_object_size (struct obstack *<var>obstack-ptr</var>)</code>
-<dd>Get the current size of the currently growing object.  See <a href="#Growing%20Objects">Growing Objects</a>.
+<dd>Get the current size of the currently growing object.  See <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_blank_fast (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</code>
 <dd>Add <var>size</var> uninitialized bytes to a growing object without checking
-that there is enough room.  See <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+that there is enough room.  See <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>void obstack_1grow_fast (struct obstack *<var>obstack-ptr</var>, char <var>data-char</var>)</code>
 <dd>Add one byte containing <var>data-char</var> to a growing object without
-checking that there is enough room.  See <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+checking that there is enough room.  See <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>int obstack_room (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>Get the amount of room now available for growing the current object. 
-See <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+See <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>int obstack_alignment_mask (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>The mask used for aligning the beginning of an object.  This is an
-lvalue.  See <a href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>.
+lvalue.  See <a href="#Obstacks Data Alignment">Obstacks Data Alignment</a>.
 
 <br><dt><code>int obstack_chunk_size (struct obstack *<var>obstack-ptr</var>)</code>
-<dd>The size for allocating chunks.  This is an lvalue.  See <a href="#Obstack%20Chunks">Obstack Chunks</a>.
+<dd>The size for allocating chunks.  This is an lvalue.  See <a href="#Obstack Chunks">Obstack Chunks</a>.
 
 <br><dt><code>void *obstack_base (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>Tentative starting address of the currently growing object. 
-See <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>.
+See <a href="#Status of an Obstack">Status of an Obstack</a>.
 
 <br><dt><code>void *obstack_next_free (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>Address just after the end of the currently growing object. 
-See <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>. 
+See <a href="#Status of an Obstack">Status of an Obstack</a>. 
 </dl>
 
 <p><hr>
-Node:<a name="Variable%20Size%20Automatic">Variable Size Automatic</a>,
+Node:<a name="Variable Size Automatic">Variable Size Automatic</a>,
 Previous:<a rel=previous accesskey=p href="#Obstacks">Obstacks</a>,
-Up:<a rel=up accesskey=u href="#Memory%20Allocation">Memory Allocation</a>
+Up:<a rel=up accesskey=u href="#Memory Allocation">Memory Allocation</a>
 <br>
 
 <h4>Automatic Storage with Variable Size</h4>
 
@@ -7632,16 +7413,15 @@
 <p>The prototype for <code>alloca</code> is in <code>stdlib.h</code>.  This function is
 a BSD extension.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>alloca</b><i> (size_t <var>size</var>);
-</i></td>
+<td align="left"><code>void * <b>alloca</b><i> (size_t <var>size</var>);</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The return value of <code>alloca</code> is the address of a block of <var>size</var>
 bytes of memory, allocated in the stack frame of the calling function. 
 </td></tr>
@@ -7653,20 +7433,20 @@
 the function arguments.  An example of what to avoid is <code>foo (x,
 alloca (4), y)</code>.
 
 <ul>
-<li><a accesskey=1 href="#Alloca%20Example">Alloca Example</a>:               Example of using <code>alloca</code>. 
-<li><a accesskey=2 href="#Advantages%20of%20Alloca">Advantages of Alloca</a>:         Reasons to use <code>alloca</code>. 
-<li><a accesskey=3 href="#Disadvantages%20of%20Alloca">Disadvantages of Alloca</a>:      Reasons to avoid <code>alloca</code>. 
-<li><a accesskey=4 href="#GNU%20C%20Variable-Size%20Arrays">GNU C Variable-Size Arrays</a>:   Only in GNU C, here is an alternative
+<li><a accesskey=1 href="#Alloca Example">Alloca Example</a>:               Example of using <code>alloca</code>. 
+<li><a accesskey=2 href="#Advantages of Alloca">Advantages of Alloca</a>:         Reasons to use <code>alloca</code>. 
+<li><a accesskey=3 href="#Disadvantages of Alloca">Disadvantages of Alloca</a>:      Reasons to avoid <code>alloca</code>. 
+<li><a accesskey=4 href="#GNU C Variable-Size Arrays">GNU C Variable-Size Arrays</a>:   Only in GNU C, here is an alternative
 				 method of allocating dynamically and
 				 freeing automatically. 
 </ul>
 
 <p><hr>
-Node:<a name="Alloca%20Example">Alloca Example</a>,
-Next:<a rel=next accesskey=n href="#Advantages%20of%20Alloca">Advantages of Alloca</a>,
-Up:<a rel=up accesskey=u href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
+Node:<a name="Alloca Example">Alloca Example</a>,
+Next:<a rel=next accesskey=n href="#Advantages of Alloca">Advantages of Alloca</a>,
+Up:<a rel=up accesskey=u href="#Variable Size Automatic">Variable Size Automatic</a>
 <br>
 
 <h5><code>alloca</code> Example</h5>
 
@@ -7703,12 +7483,12 @@
 <p>As you can see, it is simpler with <code>alloca</code>.  But <code>alloca</code> has
 other, more important advantages, and some disadvantages.
 
 <p><hr>
-Node:<a name="Advantages%20of%20Alloca">Advantages of Alloca</a>,
-Next:<a rel=next accesskey=n href="#Disadvantages%20of%20Alloca">Disadvantages of Alloca</a>,
-Previous:<a rel=previous accesskey=p href="#Alloca%20Example">Alloca Example</a>,
-Up:<a rel=up accesskey=u href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
+Node:<a name="Advantages of Alloca">Advantages of Alloca</a>,
+Next:<a rel=next accesskey=n href="#Disadvantages of Alloca">Disadvantages of Alloca</a>,
+Previous:<a rel=previous accesskey=p href="#Alloca Example">Alloca Example</a>,
+Up:<a rel=up accesskey=u href="#Variable Size Automatic">Variable Size Automatic</a>
 <br>
 
 <h5>Advantages of <code>alloca</code></h5>
 
@@ -7721,9 +7501,9 @@
 <li>Since <code>alloca</code> does not have separate pools for different sizes of
 block, space used for any size block can be reused for any other size. 
 <code>alloca</code> does not cause memory fragmentation.
 
-<li>Nonlocal exits done with <code>longjmp</code> (see <a href="#Non-Local%20Exits">Non-Local Exits</a>)
+<li>Nonlocal exits done with <code>longjmp</code> (see <a href="#Non-Local Exits">Non-Local Exits</a>)
 automatically free the space allocated with <code>alloca</code> when they exit
 through the function that called <code>alloca</code>.  This is the most
 important reason to use <code>alloca</code>.
 
@@ -7731,9 +7511,9 @@
 <code>open_or_report_error</code> which returns a descriptor, like
 <code>open</code>, if it succeeds, but does not return to its caller if it
 fails.  If the file cannot be opened, it prints an error message and
 jumps out to the command level of your program using <code>longjmp</code>. 
-Let's change <code>open2</code> (see <a href="#Alloca%20Example">Alloca Example</a>) to use this
+Let's change <code>open2</code> (see <a href="#Alloca Example">Alloca Example</a>) to use this
 subroutine:
 
 <br><pre>int
 open2 (char *str1, char *str2, int flags, int mode)
@@ -7753,12 +7533,12 @@
 fix it, there is no easy way to do so. 
 </ul>
 
 <p><hr>
-Node:<a name="Disadvantages%20of%20Alloca">Disadvantages of Alloca</a>,
-Next:<a rel=next accesskey=n href="#GNU%20C%20Variable-Size%20Arrays">GNU C Variable-Size Arrays</a>,
-Previous:<a rel=previous accesskey=p href="#Advantages%20of%20Alloca">Advantages of Alloca</a>,
-Up:<a rel=up accesskey=u href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
+Node:<a name="Disadvantages of Alloca">Disadvantages of Alloca</a>,
+Next:<a rel=next accesskey=n href="#GNU C Variable-Size Arrays">GNU C Variable-Size Arrays</a>,
+Previous:<a rel=previous accesskey=p href="#Advantages of Alloca">Advantages of Alloca</a>,
+Up:<a rel=up accesskey=u href="#Variable Size Automatic">Variable Size Automatic</a>
 <br>
 
 <h5>Disadvantages of <code>alloca</code></h5>
 
@@ -7768,19 +7548,19 @@
 <ul>
 <li>If you try to allocate more memory than the machine can provide, you
 don't get a clean error message.  Instead you get a fatal signal like
 the one you would get from an infinite recursion; probably a
-segmentation violation (see <a href="#Program%20Error%20Signals">Program Error Signals</a>).
+segmentation violation (see <a href="#Program Error Signals">Program Error Signals</a>).
 
 <li>Some non-GNU systems fail to support <code>alloca</code>, so it is less
 portable.  However, a slower emulation of <code>alloca</code> written in C
 is available for use on systems with this deficiency. 
 </ul>
 
 <p><hr>
-Node:<a name="GNU%20C%20Variable-Size%20Arrays">GNU C Variable-Size Arrays</a>,
-Previous:<a rel=previous accesskey=p href="#Disadvantages%20of%20Alloca">Disadvantages of Alloca</a>,
-Up:<a rel=up accesskey=u href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
+Node:<a name="GNU C Variable-Size Arrays">GNU C Variable-Size Arrays</a>,
+Previous:<a rel=previous accesskey=p href="#Disadvantages of Alloca">Disadvantages of Alloca</a>,
+Up:<a rel=up accesskey=u href="#Variable Size Automatic">Variable Size Automatic</a>
 <br>
 
 <h5>GNU C Variable-Size Arrays</h5>
 
@@ -7813,32 +7593,31 @@
 declared frees all blocks allocated with <code>alloca</code> during the
 execution of that scope.
 
 <p><hr>
-Node:<a name="Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>,
-Previous:<a rel=previous accesskey=p href="#Locking%20Pages">Locking Pages</a>,
+Node:<a name="Resizing the Data Segment">Resizing the Data Segment</a>,
+Previous:<a rel=previous accesskey=p href="#Locking Pages">Locking Pages</a>,
 Up:<a rel=up accesskey=u href="#Memory">Memory</a>
 <br>
 
 <h3>Resizing the Data Segment</h3>
 
 <p>The symbols in this section are declared in <code>unistd.h</code>.
 
 <p>You will not normally use the functions in this section, because the
-functions described in <a href="#Memory%20Allocation">Memory Allocation</a> are easier to use.  Those
+functions described in <a href="#Memory Allocation">Memory Allocation</a> are easier to use.  Those
 are interfaces to a GNU C Library memory allocator that uses the
 functions below itself.  The functions below are simple interfaces to
 system calls.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>brk</b><i> (void *<var>addr</var>)
-</i></td>
+<td align="left"><code>int <b>brk</b><i> (void *<var>addr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>brk</code> sets the high end of the calling process' data segment to
 <var>addr</var>.
@@ -7849,9 +7628,9 @@
 <p>The function has no effect if <var>addr</var> is lower than the low end of
 the data segment.  (This is considered success, by the way).
 
 <p>The function fails if it would cause the data segment to overlap another
-segment or exceed the process' data storage limit (see <a href="#Limits%20on%20Resources">Limits on Resources</a>).
+segment or exceed the process' data storage limit (see <a href="#Limits on Resources">Limits on Resources</a>).
 
 <p>The function is named for a common historical case where data storage
 and the stack are in the same segment.  Data storage allocation grows
 upward from the bottom of the segment while the stack grows downward
@@ -7871,16 +7650,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sbrk</b><i> (ptrdiff_t <var>delta</var>)
-</i></td>
+<td align="left"><code>int <b>sbrk</b><i> (ptrdiff_t <var>delta</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is the same as <code>brk</code> except that you specify the new
 end of the data segment as an offset <var>delta</var> from the current end
 and on success the return value is the address of the resulting end of
@@ -7892,11 +7670,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Locking%20Pages">Locking Pages</a>,
-Next:<a rel=next accesskey=n href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>,
-Previous:<a rel=previous accesskey=p href="#Memory%20Allocation">Memory Allocation</a>,
+Node:<a name="Locking Pages">Locking Pages</a>,
+Next:<a rel=next accesskey=n href="#Resizing the Data Segment">Resizing the Data Segment</a>,
+Previous:<a rel=previous accesskey=p href="#Memory Allocation">Memory Allocation</a>,
 Up:<a rel=up accesskey=u href="#Memory">Memory</a>
 <br>
 
 <h3>Locking Pages</h3>
@@ -7910,18 +7688,18 @@
 <p>The functions in this chapter lock and unlock the calling process'
 pages.
 
 <ul>
-<li><a accesskey=1 href="#Why%20Lock%20Pages">Why Lock Pages</a>:                 Reasons to read this section. 
-<li><a accesskey=2 href="#Locked%20Memory%20Details">Locked Memory Details</a>:          Everything you need to know locked
+<li><a accesskey=1 href="#Why Lock Pages">Why Lock Pages</a>:                 Reasons to read this section. 
+<li><a accesskey=2 href="#Locked Memory Details">Locked Memory Details</a>:          Everything you need to know locked
                                     memory
-<li><a accesskey=3 href="#Page%20Lock%20Functions">Page Lock Functions</a>:            Here's how to do it. 
+<li><a accesskey=3 href="#Page Lock Functions">Page Lock Functions</a>:            Here's how to do it. 
 </ul>
 
 <p><hr>
-Node:<a name="Why%20Lock%20Pages">Why Lock Pages</a>,
-Next:<a rel=next accesskey=n href="#Locked%20Memory%20Details">Locked Memory Details</a>,
-Up:<a rel=up accesskey=u href="#Locking%20Pages">Locking Pages</a>
+Node:<a name="Why Lock Pages">Why Lock Pages</a>,
+Next:<a rel=next accesskey=n href="#Locked Memory Details">Locked Memory Details</a>,
+Up:<a rel=up accesskey=u href="#Locking Pages">Locking Pages</a>
 <br>
 
 <h4>Why Lock Pages</h4>
 
@@ -7956,12 +7734,12 @@
 slowly.  In fact, if you lock enough memory, some programs may not be
 able to run at all for lack of real memory.
 
 <p><hr>
-Node:<a name="Locked%20Memory%20Details">Locked Memory Details</a>,
-Next:<a rel=next accesskey=n href="#Page%20Lock%20Functions">Page Lock Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Why%20Lock%20Pages">Why Lock Pages</a>,
-Up:<a rel=up accesskey=u href="#Locking%20Pages">Locking Pages</a>
+Node:<a name="Locked Memory Details">Locked Memory Details</a>,
+Next:<a rel=next accesskey=n href="#Page Lock Functions">Page Lock Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Why Lock Pages">Why Lock Pages</a>,
+Up:<a rel=up accesskey=u href="#Locking Pages">Locking Pages</a>
 <br>
 
 <h4>Locked Memory Details</h4>
 
@@ -7979,15 +7757,15 @@
 
 <p>Memory locks are not inherited by child processes.  (But note that on a
 modern Unix system, immediately after a fork, the parent's and the
 child's virtual address space are backed by the same real page frames,
-so the child enjoys the parent's locks).  See <a href="#Creating%20a%20Process">Creating a Process</a>.
+so the child enjoys the parent's locks).  See <a href="#Creating a Process">Creating a Process</a>.
 
 <p>Because of its ability to impact other processes, only the superuser can
 lock a page.  Any process can unlock its own page.
 
 <p>The system sets limits on the amount of memory a process can have locked
-and the amount of real memory it can have dedicated to it.  See <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+and the amount of real memory it can have dedicated to it.  See <a href="#Limits on Resources">Limits on Resources</a>.
 
 <p>In Linux, locked pages aren't as locked as you might think. 
 Two virtual pages that are not shared memory can nonetheless be backed
 by the same real frame.  The kernel does this in the name of efficiency
@@ -8006,11 +7784,11 @@
 maximum stack size you will need, set it to something, then return from
 its scope.
 
 <p><hr>
-Node:<a name="Page%20Lock%20Functions">Page Lock Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Locked%20Memory%20Details">Locked Memory Details</a>,
-Up:<a rel=up accesskey=u href="#Locking%20Pages">Locking Pages</a>
+Node:<a name="Page Lock Functions">Page Lock Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Locked Memory Details">Locked Memory Details</a>,
+Up:<a rel=up accesskey=u href="#Locking Pages">Locking Pages</a>
 <br>
 
 <h4>Functions To Lock And Unlock Pages</h4>
 
@@ -8028,16 +7806,15 @@
 define the macro <code>_POSIX_MEMLOCK</code>.  The GNU C library conforms to
 this requirement.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mlock</b><i> (const void *<var>addr</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>int <b>mlock</b><i> (const void *<var>addr</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>mlock</code> locks a range of the calling process' virtual pages.
 
@@ -8088,16 +7865,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>munlock</b><i> (const void *<var>addr</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>int <b>munlock</b><i> (const void *<var>addr</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>mlock</code> unlocks a range of the calling process' virtual pages.
 
@@ -8108,16 +7884,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mlockall</b><i> (int <var>flags</var>)
-</i></td>
+<td align="left"><code>int <b>mlockall</b><i> (int <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>mlockall</code> locks all the pages in a process' virtual memory address
 space, and/or any that are added to it in the future.  This includes the
@@ -8138,9 +7913,9 @@
 <dd>Set a mode such that any pages added to the process' virtual address
 space in the future will be locked from birth.  This mode does not
 affect future address spaces owned by the same process so exec, which
 replaces a process' address space, wipes out <code>MCL_FUTURE</code>. 
-See <a href="#Executing%20a%20File">Executing a File</a>.
+See <a href="#Executing a File">Executing a File</a>.
 
 </dl>
 
 <p>When the function returns successfully, and you specified
@@ -8190,16 +7965,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>munlockall</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>munlockall</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>munlockall</code> unlocks every page in the calling process' virtual
 address space and turn off <code>MCL_FUTURE</code> future locking mode.
@@ -8212,10 +7986,10 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Character%20Handling">Character Handling</a>,
-Next:<a rel=next accesskey=n href="#String%20and%20Array%20Utilities">String and Array Utilities</a>,
+Node:<a name="Character Handling">Character Handling</a>,
+Next:<a rel=next accesskey=n href="#String and Array Utilities">String and Array Utilities</a>,
 Previous:<a rel=previous accesskey=p href="#Memory">Memory</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -8230,31 +8004,31 @@
 <p>Since the choice of locale and character set can alter the
 classifications of particular character codes, all of these functions
 are affected by the current locale.  (More precisely, they are affected
 by the locale currently selected for character classification--the
-<code>LC_CTYPE</code> category; see <a href="#Locale%20Categories">Locale Categories</a>.)
+<code>LC_CTYPE</code> category; see <a href="#Locale Categories">Locale Categories</a>.)
 
 <p>The ISO&nbsp;C standard specifies two different sets of functions.  The
 one set works on <code>char</code> type characters, the other one on
-<code>wchar_t</code> wide characters (see <a href="#Extended%20Char%20Intro">Extended Char Intro</a>).
+<code>wchar_t</code> wide characters (see <a href="#Extended Char Intro">Extended Char Intro</a>).
 
 <ul>
-<li><a accesskey=1 href="#Classification%20of%20Characters">Classification of Characters</a>:        Testing whether characters are
+<li><a accesskey=1 href="#Classification of Characters">Classification of Characters</a>:        Testing whether characters are
 			                letters, digits, punctuation, etc.
 
 <p>
-</p><li><a accesskey=2 href="#Case%20Conversion">Case Conversion</a>:                     Case mapping, and the like. 
-<li><a accesskey=3 href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>:   Character class determination for
+</p><li><a accesskey=2 href="#Case Conversion">Case Conversion</a>:                     Case mapping, and the like. 
+<li><a accesskey=3 href="#Classification of Wide Characters">Classification of Wide Characters</a>:   Character class determination for
                                         wide characters. 
-<li><a accesskey=4 href="#Using%20Wide%20Char%20Classes">Using Wide Char Classes</a>:             Notes on using the wide character
+<li><a accesskey=4 href="#Using Wide Char Classes">Using Wide Char Classes</a>:             Notes on using the wide character
                                         classes. 
-<li><a accesskey=5 href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>:      Mapping of wide characters. 
+<li><a accesskey=5 href="#Wide Character Case Conversion">Wide Character Case Conversion</a>:      Mapping of wide characters. 
 </ul>
 
 <p><hr>
-Node:<a name="Classification%20of%20Characters">Classification of Characters</a>,
-Next:<a rel=next accesskey=n href="#Case%20Conversion">Case Conversion</a>,
-Up:<a rel=up accesskey=u href="#Character%20Handling">Character Handling</a>
+Node:<a name="Classification of Characters">Classification of Characters</a>,
+Next:<a rel=next accesskey=n href="#Case Conversion">Case Conversion</a>,
+Up:<a rel=up accesskey=u href="#Character Handling">Character Handling</a>
 <br>
 
 <h3>Classification of Characters</h3>
 
@@ -8264,9 +8038,9 @@
 nonzero integer if the character is alphabetic, and zero otherwise.  You
 would use it like this:
 
 <br><pre>if (isalpha (c))
-  printf ("The character `%c' is alphabetic.\n", c);
+  printf ("The character '%c' is alphabetic.\n", c);
 </pre>
 
 <p>Each of the functions in this section tests for membership in a
 particular class of characters; each has a name starting with <code>is</code>. 
@@ -8280,46 +8054,43 @@
 
 <p>These functions are declared in the header file <code>ctype.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>islower</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>islower</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a lower-case letter.  The letter need not be
 from the Latin alphabet, any alphabet representable is valid. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isupper</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isupper</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is an upper-case letter.  The letter need not be
 from the Latin alphabet, any alphabet representable is valid. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isalpha</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isalpha</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is an alphabetic character (a letter).  If
 <code>islower</code> or <code>isupper</code> is true of a character, then
 <code>isalpha</code> is also true.
@@ -8331,46 +8102,43 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isdigit</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isdigit</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a decimal digit (<code>0</code> through <code>9</code>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isalnum</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isalnum</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is an alphanumeric character (a letter or
 number); in other words, if either <code>isalpha</code> or <code>isdigit</code> is
 true of a character, then <code>isalnum</code> is also true. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isxdigit</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isxdigit</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a hexadecimal digit. 
 Hexadecimal digits include the normal decimal digits <code>0</code> through
 <code>9</code> and the letters <code>A</code> through <code>F</code> and
@@ -8378,32 +8146,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ispunct</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>ispunct</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a punctuation character. 
 This means any printing character that is not alphanumeric or a space
 character. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isspace</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isspace</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a <dfn>whitespace</dfn> character.  In the standard
 <code>"C"</code> locale, <code>isspace</code> returns true for only the standard
 whitespace characters:
@@ -8430,89 +8196,84 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isblank</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isblank</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a blank character; that is, a space or a tab. 
 This function is a GNU extension. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isgraph</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isgraph</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a graphic character; that is, a character
 that has a glyph associated with it.  The whitespace characters are not
 considered graphic. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isprint</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isprint</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a printing character.  Printing characters
 include all the graphic characters, plus the space (<code> </code>) character. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iscntrl</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>iscntrl</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a control character (that is, a character that
 is not a printing character). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isascii</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>isascii</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>c</var> is a 7-bit <code>unsigned char</code> value that fits
 into the US/UK ASCII character set.  This function is a BSD extension
 and is also an SVID extension. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Case%20Conversion">Case Conversion</a>,
-Next:<a rel=next accesskey=n href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>,
-Previous:<a rel=previous accesskey=p href="#Classification%20of%20Characters">Classification of Characters</a>,
-Up:<a rel=up accesskey=u href="#Character%20Handling">Character Handling</a>
+Node:<a name="Case Conversion">Case Conversion</a>,
+Next:<a rel=next accesskey=n href="#Classification of Wide Characters">Classification of Wide Characters</a>,
+Previous:<a rel=previous accesskey=p href="#Classification of Characters">Classification of Characters</a>,
+Up:<a rel=up accesskey=u href="#Character Handling">Character Handling</a>
 <br>
 
 <h3>Case Conversion</h3>
 
@@ -8534,89 +8295,84 @@
 
 <p>These functions are declared in the header file <code>ctype.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tolower</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>tolower</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>c</var> is an upper-case letter, <code>tolower</code> returns the corresponding
 lower-case letter.  If <var>c</var> is not an upper-case letter,
 <var>c</var> is returned unchanged. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>toupper</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>toupper</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>c</var> is a lower-case letter, <code>toupper</code> returns the corresponding
 upper-case letter.  Otherwise <var>c</var> is returned unchanged. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>toascii</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>toascii</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts <var>c</var> to a 7-bit <code>unsigned char</code> value
 that fits into the US/UK ASCII character set, by clearing the high-order
 bits.  This function is a BSD extension and is also an SVID extension. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_tolower</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>_tolower</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is identical to <code>tolower</code>, and is provided for compatibility
 with the SVID.  See <a href="#SVID">SVID</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_toupper</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>_toupper</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is identical to <code>toupper</code>, and is provided for compatibility
 with the SVID. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>,
-Next:<a rel=next accesskey=n href="#Using%20Wide%20Char%20Classes">Using Wide Char Classes</a>,
-Previous:<a rel=previous accesskey=p href="#Case%20Conversion">Case Conversion</a>,
-Up:<a rel=up accesskey=u href="#Character%20Handling">Character Handling</a>
+Node:<a name="Classification of Wide Characters">Classification of Wide Characters</a>,
+Next:<a rel=next accesskey=n href="#Using Wide Char Classes">Using Wide Char Classes</a>,
+Previous:<a rel=previous accesskey=p href="#Case Conversion">Case Conversion</a>,
+Up:<a rel=up accesskey=u href="#Character Handling">Character Handling</a>
 <br>
 
 <h3>Character class determination for wide characters</h3>
 
@@ -8644,16 +8400,15 @@
 this the normal character classification functions as used for
 <code>char</code> objects can be defined.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>wctype_t</b><i>
-</i></td>
+<td align="left"><code><b>wctype_t</b><i></i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wctype_t</code> can hold a value which represents a character class. 
 The only defined way to generate such a value is by using the
 <code>wctype</code> function.
@@ -8662,16 +8417,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wctype_t <b>wctype</b><i> (const char *<var>property</var>)
-</i></td>
+<td align="left"><code>wctype_t <b>wctype</b><i> (const char *<var>property</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wctype</code> returns a value representing a class of wide
 characters which is identified by the string <var>property</var>.  Beside
 some standard properties each locale can define its own ones.  In case
@@ -8692,16 +8446,15 @@
 <p>To test the membership of a character to one of the non-standard classes
 the ISO&nbsp;C standard defines a completely new function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswctype</b><i> (wint_t <var>wc</var>, wctype_t <var>desc</var>)
-</i></td>
+<td align="left"><code>int <b>iswctype</b><i> (wint_t <var>wc</var>, wctype_t <var>desc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a nonzero value if <var>wc</var> is in the character
 class specified by <var>desc</var>.  <var>desc</var> must previously be returned
 by a successful call to <code>wctype</code>.
@@ -8717,16 +8470,15 @@
 strings, and then it is important that <code>wctype</code> can also handle the
 standard classes.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswalnum</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswalnum</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a nonzero value if <var>wc</var> is an alphanumeric
 character (a letter or number); in other words, if either <code>iswalpha</code>
 or <code>iswdigit</code> is true of a character, then <code>iswalnum</code> is also
@@ -8741,16 +8493,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswalpha</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswalpha</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is an alphabetic character (a letter).  If
 <code>iswlower</code> or <code>iswupper</code> is true of a character, then
 <code>iswalpha</code> is also true.
@@ -8769,16 +8520,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswcntrl</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswcntrl</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a control character (that is, a character that
 is not a printing character).
 
@@ -8791,16 +8541,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswdigit</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswdigit</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a digit (e.g., <code>0</code> through <code>9</code>). 
 Please note that this function does not only return a nonzero value for
 <em>decimal</em> digits, but for all kinds of digits.  A consequence is
@@ -8824,16 +8573,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswgraph</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswgraph</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a graphic character; that is, a character
 that has a glyph associated with it.  The whitespace characters are not
 considered graphic.
@@ -8847,16 +8595,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswlower</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswlower</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a lower-case letter.  The letter need not be
 from the Latin alphabet, any alphabet representable is valid.
 
@@ -8869,16 +8616,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswprint</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswprint</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a printing character.  Printing characters
 include all the graphic characters, plus the space (<code> </code>) character.
 
@@ -8891,16 +8637,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswpunct</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswpunct</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a punctuation character. 
 This means any printing character that is not alphanumeric or a space
 character.
@@ -8914,16 +8659,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswspace</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswspace</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a <dfn>whitespace</dfn> character.  In the standard
 <code>"C"</code> locale, <code>iswspace</code> returns true for only the standard
 whitespace characters:
@@ -8957,16 +8701,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswupper</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswupper</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is an upper-case letter.  The letter need not be
 from the Latin alphabet, any alphabet representable is valid.
 
@@ -8979,16 +8722,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswxdigit</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswxdigit</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a hexadecimal digit. 
 Hexadecimal digits include the normal decimal digits <code>0</code> through
 <code>9</code> and the letters <code>A</code> through <code>F</code> and
@@ -9007,27 +8749,26 @@
 ISO&nbsp;C standard but which is available as a version for single byte
 characters as well.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iswblank</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>int <b>iswblank</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns true if <var>wc</var> is a blank character; that is, a space or a tab. 
 This function is a GNU extension.  It is declared in <code>wchar.h</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Using%20Wide%20Char%20Classes">Using Wide Char Classes</a>,
-Next:<a rel=next accesskey=n href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>,
-Up:<a rel=up accesskey=u href="#Character%20Handling">Character Handling</a>
+Node:<a name="Using Wide Char Classes">Using Wide Char Classes</a>,
+Next:<a rel=next accesskey=n href="#Wide Character Case Conversion">Wide Character Case Conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Classification of Wide Characters">Classification of Wide Characters</a>,
+Up:<a rel=up accesskey=u href="#Character Handling">Character Handling</a>
 <br>
 
 <h3>Notes on using the wide character classes</h3>
 
@@ -9079,9 +8820,9 @@
   return desc ? iswctype (btowc (c), desc) : 0;
 }
 </pre>
 
-<p>See <a href="#Converting%20a%20Character">Converting a Character</a>, for more information on <code>btowc</code>. 
+<p>See <a href="#Converting a Character">Converting a Character</a>, for more information on <code>btowc</code>. 
 Note that this change probably does not improve the performance
 of the program a lot since the <code>wctype</code> function still has to make
 the string comparisons.  It gets really interesting if the
 <code>is_in_class</code> function is called more than once for the
@@ -9089,11 +8830,11 @@
 once and reused for all the calls.  Therefore the above form of the
 function is probably not the final one.
 
 <p><hr>
-Node:<a name="Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Using%20Wide%20Char%20Classes">Using Wide Char Classes</a>,
-Up:<a rel=up accesskey=u href="#Character%20Handling">Character Handling</a>
+Node:<a name="Wide Character Case Conversion">Wide Character Case Conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Using Wide Char Classes">Using Wide Char Classes</a>,
+Up:<a rel=up accesskey=u href="#Character Handling">Character Handling</a>
 <br>
 
 <h3>Mapping of wide characters.</h3>
 
@@ -9102,16 +8843,15 @@
 locale can contain others.  Again, the <code>localedef</code> program
 already supports generating such locale data files.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>wctrans_t</b><i>
-</i></td>
+<td align="left"><code><b>wctrans_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is defined as a scalar type which can hold a value
 representing the locale-dependent character mapping.  There is no way to
 construct such a value apart from using the return value of the
@@ -9121,16 +8861,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wctrans_t <b>wctrans</b><i> (const char *<var>property</var>)
-</i></td>
+<td align="left"><code>wctrans_t <b>wctrans</b><i> (const char *<var>property</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wctrans</code> function has to be used to find out whether a named
 mapping is defined in the current locale selected for the
 <code>LC_CTYPE</code> category.  If the returned value is non-zero, you can use
@@ -9147,16 +8886,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>towctrans</b><i> (wint_t <var>wc</var>, wctrans_t <var>desc</var>)
-</i></td>
+<td align="left"><code>wint_t <b>towctrans</b><i> (wint_t <var>wc</var>, wctrans_t <var>desc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>towctrans</code> maps the input character <var>wc</var>
 according to the rules of the mapping for which <var>desc</var> is a
 descriptor, and returns the value it finds.  <var>desc</var> must be
@@ -9170,16 +8908,15 @@
 convenient shortcuts so that it is not necessary to call <code>wctrans</code>
 for them.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>towlower</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>wint_t <b>towlower</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>wc</var> is an upper-case letter, <code>towlower</code> returns the corresponding
 lower-case letter.  If <var>wc</var> is not an upper-case letter,
 <var>wc</var> is returned unchanged.
@@ -9193,16 +8930,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>towupper</b><i> (wint_t <var>wc</var>)
-</i></td>
+<td align="left"><code>wint_t <b>towupper</b><i> (wint_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>wc</var> is a lower-case letter, <code>towupper</code> returns the corresponding
 upper-case letter.  Otherwise <var>wc</var> is returned unchanged.
 
@@ -9220,11 +8956,11 @@
 simply cast a <code>char</code> type value to a <code>wint_t</code> and use it as an
 argument to <code>towctrans</code> calls.
 
 <p><hr>
-Node:<a name="String%20and%20Array%20Utilities">String and Array Utilities</a>,
-Next:<a rel=next accesskey=n href="#Character%20Set%20Handling">Character Set Handling</a>,
-Previous:<a rel=previous accesskey=p href="#Character%20Handling">Character Handling</a>,
+Node:<a name="String and Array Utilities">String and Array Utilities</a>,
+Next:<a rel=next accesskey=n href="#Character Set Handling">Character Set Handling</a>,
+Previous:<a rel=previous accesskey=p href="#Character Handling">Character Handling</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>String and Array Utilities</h2>
@@ -9247,30 +8983,30 @@
 functions are typically highly optimized, your program may run faster
 too.
 
 <ul>
-<li><a accesskey=1 href="#Representation%20of%20Strings">Representation of Strings</a>:    Introduction to basic concepts. 
-<li><a accesskey=2 href="#String%2fArray%20Conventions">String/Array Conventions</a>:     Whether to use a string function or an
+<li><a accesskey=1 href="#Representation of Strings">Representation of Strings</a>:    Introduction to basic concepts. 
+<li><a accesskey=2 href="#String%2fArray Conventions">String/Array Conventions</a>:     Whether to use a string function or an
 				 arbitrary array function. 
-<li><a accesskey=3 href="#String%20Length">String Length</a>:                Determining the length of a string. 
-<li><a accesskey=4 href="#Copying%20and%20Concatenation">Copying and Concatenation</a>:    Functions to copy the contents of strings
+<li><a accesskey=3 href="#String Length">String Length</a>:                Determining the length of a string. 
+<li><a accesskey=4 href="#Copying and Concatenation">Copying and Concatenation</a>:    Functions to copy the contents of strings
 				 and arrays. 
-<li><a accesskey=5 href="#String%2fArray%20Comparison">String/Array Comparison</a>:      Functions for byte-wise and character-wise
+<li><a accesskey=5 href="#String%2fArray Comparison">String/Array Comparison</a>:      Functions for byte-wise and character-wise
 				 comparison. 
-<li><a accesskey=6 href="#Collation%20Functions">Collation Functions</a>:          Functions for collating strings. 
-<li><a accesskey=7 href="#Search%20Functions">Search Functions</a>:             Searching for a specific element or substring. 
-<li><a accesskey=8 href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>:   Splitting a string into tokens by looking
+<li><a accesskey=6 href="#Collation Functions">Collation Functions</a>:          Functions for collating strings. 
+<li><a accesskey=7 href="#Search Functions">Search Functions</a>:             Searching for a specific element or substring. 
+<li><a accesskey=8 href="#Finding Tokens in a String">Finding Tokens in a String</a>:   Splitting a string into tokens by looking
 				 for delimiters. 
 <li><a accesskey=9 href="#strfry">strfry</a>:                       Function for flash-cooking a string. 
-<li><a href="#Trivial%20Encryption">Trivial Encryption</a>:           Obscuring data. 
-<li><a href="#Encode%20Binary%20Data">Encode Binary Data</a>:           Encoding and Decoding of Binary Data. 
-<li><a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>:        Null-separated string vectors. 
+<li><a href="#Trivial Encryption">Trivial Encryption</a>:           Obscuring data. 
+<li><a href="#Encode Binary Data">Encode Binary Data</a>:           Encoding and Decoding of Binary Data. 
+<li><a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>:        Null-separated string vectors. 
 </ul>
 
 <p><hr>
-Node:<a name="Representation%20of%20Strings">Representation of Strings</a>,
-Next:<a rel=next accesskey=n href="#String%2fArray%20Conventions">String/Array Conventions</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="Representation of Strings">Representation of Strings</a>,
+Next:<a rel=next accesskey=n href="#String%2fArray Conventions">String/Array Conventions</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Representation of Strings</h3>
 
@@ -9282,9 +9018,9 @@
 <p>A <dfn>string</dfn> is an array of <code>char</code> objects.  But string-valued
 variables are usually declared to be pointers of type <code>char *</code>. 
 Such variables do not include space for the text of a string; that has
 to be stored somewhere else--in an array variable, a string constant,
-or dynamically allocated memory (see <a href="#Memory%20Allocation">Memory Allocation</a>).  It's up to
+or dynamically allocated memory (see <a href="#Memory Allocation">Memory Allocation</a>).  It's up to
 you to store the address of the chosen memory space into the pointer
 variable.  Alternatively you can store a <dfn>null pointer</dfn> in the
 pointer variable.  The null pointer does not point anywhere, so
 attempting to reference the string it points to gets an error.
@@ -9340,9 +9076,9 @@
 <p>Originally strings were sequences of bytes where each byte represents a
 single character.  This is still true today if the strings are encoded
 using a single-byte character encoding.  Things are different if the
 strings are encoded using a multibyte encoding (for more information on
-encodings see <a href="#Extended%20Char%20Intro">Extended Char Intro</a>).  There is no difference in
+encodings see <a href="#Extended Char Intro">Extended Char Intro</a>).  There is no difference in
 the programming interface for these two kind of strings; the programmer
 has to be aware of this and interpret the byte sequences accordingly.
 
 <p>But since there is no separate interface taking care of these
@@ -9352,9 +9088,9 @@
 incomplete (and therefore unusable) byte sequence in the target buffer.
 
 <p>To avoid these problems later versions of the ISO&nbsp;C standard
 introduce a second set of functions which are operating on <dfn>wide
-characters</dfn> (see <a href="#Extended%20Char%20Intro">Extended Char Intro</a>).  These functions don't have
+characters</dfn> (see <a href="#Extended Char Intro">Extended Char Intro</a>).  These functions don't have
 the problems the single-byte versions have since every wide character is
 a legal, interpretable value.  This does not mean that cutting wide
 character strings at arbitrary points is without problems.  It normally
 is for alphabet-based languages (except for non-normalized text) but
@@ -9372,12 +9108,12 @@
 character strings since there is almost always an exact equivalent
 available.
 
 <p><hr>
-Node:<a name="String%2fArray%20Conventions">String/Array Conventions</a>,
-Next:<a rel=next accesskey=n href="#String%20Length">String Length</a>,
-Previous:<a rel=previous accesskey=p href="#Representation%20of%20Strings">Representation of Strings</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="String%2fArray Conventions">String/Array Conventions</a>,
+Next:<a rel=next accesskey=n href="#String Length">String Length</a>,
+Previous:<a rel=previous accesskey=p href="#Representation of Strings">Representation of Strings</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>String and Array Conventions</h3>
 
@@ -9430,28 +9166,27 @@
 promoted, but since the ISO&nbsp;C standard does not require such a
 choice of types the <code>wint_t</code> type is used.
 
 <p><hr>
-Node:<a name="String%20Length">String Length</a>,
-Next:<a rel=next accesskey=n href="#Copying%20and%20Concatenation">Copying and Concatenation</a>,
-Previous:<a rel=previous accesskey=p href="#String%2fArray%20Conventions">String/Array Conventions</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="String Length">String Length</a>,
+Next:<a rel=next accesskey=n href="#Copying and Concatenation">Copying and Concatenation</a>,
+Previous:<a rel=previous accesskey=p href="#String%2fArray Conventions">String/Array Conventions</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>String Length</h3>
 
 <p>You can get the length of a string using the <code>strlen</code> function. 
 This function is declared in the header file <code>string.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>strlen</b><i> (const char *<var>s</var>)
-</i></td>
+<td align="left"><code>size_t <b>strlen</b><i> (const char *<var>s</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strlen</code> function returns the length of the null-terminated
 string <var>s</var> in bytes.  (In other words, it returns the offset of the
 terminating null character within the array.)
@@ -9512,16 +9247,15 @@
 
 <p>The wide character equivalent is declared in <code>wchar.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcslen</b><i> (const wchar_t *<var>ws</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcslen</b><i> (const wchar_t *<var>ws</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcslen</code> function is the wide character equivalent to
 <code>strlen</code>.  The return value is the number of wide characters in the
 wide character string pointed to by <var>ws</var> (this is also the offset of
@@ -9535,16 +9269,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>strnlen</b><i> (const char *<var>s</var>, size_t <var>maxlen</var>)
-</i></td>
+<td align="left"><code>size_t <b>strnlen</b><i> (const char *<var>s</var>, size_t <var>maxlen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strnlen</code> function returns the length of the string <var>s</var> in
 bytes if this length is smaller than <var>maxlen</var> bytes.  Otherwise it
 returns <var>maxlen</var>.  Therefore this function is equivalent to
@@ -9563,16 +9296,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcsnlen</b><i> (const wchar_t *<var>ws</var>, size_t <var>maxlen</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcsnlen</b><i> (const wchar_t *<var>ws</var>, size_t <var>maxlen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>wcsnlen</code> is the wide character equivalent to <code>strnlen</code>.  The
 <var>maxlen</var> parameter specifies the maximum number of wide characters.
 
@@ -9580,12 +9312,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Copying%20and%20Concatenation">Copying and Concatenation</a>,
-Next:<a rel=next accesskey=n href="#String%2fArray%20Comparison">String/Array Comparison</a>,
-Previous:<a rel=previous accesskey=p href="#String%20Length">String Length</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="Copying and Concatenation">Copying and Concatenation</a>,
+Next:<a rel=next accesskey=n href="#String%2fArray Comparison">String/Array Comparison</a>,
+Previous:<a rel=previous accesskey=p href="#String Length">String Length</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Copying and Concatenation</h3>
 
@@ -9610,19 +9342,18 @@
 your program.
 
 <p>All functions that have problems copying between overlapping arrays are
 explicitly identified in this manual.  In addition to functions in this
-section, there are a few others like <code>sprintf</code> (see <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>) and <code>scanf</code> (see <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>).
+section, there are a few others like <code>sprintf</code> (see <a href="#Formatted Output Functions">Formatted Output Functions</a>) and <code>scanf</code> (see <a href="#Formatted Input Functions">Formatted Input Functions</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memcpy</b><i> (void *restrict <var>to</var>, const void *restrict <var>from</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>memcpy</b><i> (void *restrict <var>to</var>, const void *restrict <var>from</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>memcpy</code> function copies <var>size</var> bytes from the object
 beginning at <var>from</var> into the object beginning at <var>to</var>.  The
 behavior of this function is undefined if the two arrays <var>to</var> and
@@ -9641,16 +9372,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wmemcpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restruct <var>wfrom</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wmemcpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restruct <var>wfrom</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wmemcpy</code> function copies <var>size</var> wide characters from the object
 beginning at <var>wfrom</var> into the object beginning at <var>wto</var>.  The
 behavior of this function is undefined if the two arrays <var>wto</var> and
@@ -9673,16 +9403,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>mempcpy</b><i> (void *restrict <var>to</var>, const void *restrict <var>from</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>mempcpy</b><i> (void *restrict <var>to</var>, const void *restrict <var>from</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mempcpy</code> function is nearly identical to the <code>memcpy</code>
 function.  It copies <var>size</var> bytes from the object beginning at
 <code>from</code> into the object pointed to by <var>to</var>.  But instead of
@@ -9707,16 +9436,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wmempcpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wmempcpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wmempcpy</code> function is nearly identical to the <code>wmemcpy</code>
 function.  It copies <var>size</var> wide characters from the object
 beginning at <code>wfrom</code> into the object pointed to by <var>wto</var>.  But
@@ -9742,16 +9470,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memmove</b><i> (void *<var>to</var>, const void *<var>from</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>memmove</b><i> (void *<var>to</var>, const void *<var>from</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>memmove</code> copies the <var>size</var> bytes at <var>from</var> into the
 <var>size</var> bytes at <var>to</var>, even if those two blocks of space
 overlap.  In the case of overlap, <code>memmove</code> is careful to copy the
@@ -9762,16 +9489,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wmemmove</b><i> (wchar *<var>wto</var>, const wchar_t *<var>wfrom</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wmemmove</b><i> (wchar *<var>wto</var>, const wchar_t *<var>wfrom</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>wmemmove</code> copies the <var>size</var> wide characters at <var>wfrom</var>
 into the <var>size</var> wide characters at <var>wto</var>, even if those two
 blocks of space overlap.  In the case of overlap, <code>memmove</code> is
@@ -9796,16 +9522,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memccpy</b><i> (void *restrict <var>to</var>, const void *restrict <var>from</var>, int <var>c</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>memccpy</b><i> (void *restrict <var>to</var>, const void *restrict <var>from</var>, int <var>c</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function copies no more than <var>size</var> bytes from <var>from</var> to
 <var>to</var>, stopping if a byte matching <var>c</var> is found.  The return
 value is a pointer into <var>to</var> one byte past where <var>c</var> was copied,
@@ -9814,48 +9539,45 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memset</b><i> (void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>memset</b><i> (void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function copies the value of <var>c</var> (converted to an
 <code>unsigned char</code>) into each of the first <var>size</var> bytes of the
 object beginning at <var>block</var>.  It returns the value of <var>block</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wmemset</b><i> (wchar_t *<var>block</var>, wchar_t <var>wc</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wmemset</b><i> (wchar_t *<var>block</var>, wchar_t <var>wc</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function copies the value of <var>wc</var> into each of the first
 <var>size</var> wide characters of the object beginning at <var>block</var>.  It
 returns the value of <var>block</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strcpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>)
-</i></td>
+<td align="left"><code>char * <b>strcpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This copies characters from the string <var>from</var> (up to and including
 the terminating null character) into the string <var>to</var>.  Like
 <code>memcpy</code>, this function has undefined results if the strings
@@ -9863,16 +9585,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcscpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcscpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This copies wide characters from the string <var>wfrom</var> (up to and
 including the terminating null wide character) into the string
 <var>wto</var>.  Like <code>wmemcpy</code>, this function has undefined results if
@@ -9880,16 +9601,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strncpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>char * <b>strncpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>strcpy</code> but always copies exactly
 <var>size</var> characters into <var>to</var>.
 
@@ -9913,16 +9633,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcsncpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcsncpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>wcscpy</code> but always copies exactly
 <var>size</var> wide characters into <var>wto</var>.
 
@@ -9947,38 +9666,36 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strdup</b><i> (const char *<var>s</var>)
-</i></td>
+<td align="left"><code>char * <b>strdup</b><i> (const char *<var>s</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function copies the null-terminated string <var>s</var> into a newly
 allocated string.  The string is allocated using <code>malloc</code>; see
-<a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>.  If <code>malloc</code> cannot allocate space
+<a href="#Unconstrained Allocation">Unconstrained Allocation</a>.  If <code>malloc</code> cannot allocate space
 for the new string, <code>strdup</code> returns a null pointer.  Otherwise it
 returns a pointer to the new string. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcsdup</b><i> (const wchar_t *<var>ws</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcsdup</b><i> (const wchar_t *<var>ws</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function copies the null-terminated wide character string <var>ws</var>
 into a newly allocated string.  The string is allocated using
-<code>malloc</code>; see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>.  If <code>malloc</code>
+<code>malloc</code>; see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>.  If <code>malloc</code>
 cannot allocate space for the new string, <code>wcsdup</code> returns a null
 pointer.  Otherwise it returns a pointer to the new wide character
 string.
 
@@ -9986,16 +9703,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strndup</b><i> (const char *<var>s</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>char * <b>strndup</b><i> (const char *<var>s</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>strdup</code> but always copies at most
 <var>size</var> characters into the newly allocated string.
 
@@ -10011,16 +9727,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>stpcpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>)
-</i></td>
+<td align="left"><code>char * <b>stpcpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>strcpy</code>, except that it returns a pointer to
 the end of the string <var>to</var> (that is, the address of the terminating
 null character <code>to + strlen (from)</code>) rather than the beginning.
@@ -10054,16 +9769,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcpcpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcpcpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>wcscpy</code>, except that it returns a pointer to
 the end of the string <var>wto</var> (that is, the address of the terminating
 null character <code>wto + strlen (wfrom)</code>) rather than the beginning.
@@ -10077,16 +9791,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>stpncpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>char * <b>stpncpy</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>stpcpy</code> but copies always exactly
 <var>size</var> characters into <var>to</var>.
 
@@ -10110,16 +9823,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcpncpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcpncpy</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>wcpcpy</code> but copies always exactly
 <var>wsize</var> characters into <var>wto</var>.
 
@@ -10145,19 +9857,18 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strdupa</b><i> (const char *<var>s</var>)
-</i></td>
+<td align="left"><code>char * <b>strdupa</b><i> (const char *<var>s</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is similar to <code>strdup</code> but allocates the new string
-using <code>alloca</code> instead of <code>malloc</code> (see <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>).  This means of course the returned string has the same
+using <code>alloca</code> instead of <code>malloc</code> (see <a href="#Variable Size Automatic">Variable Size Automatic</a>).  This means of course the returned string has the same
 limitations as any block of memory allocated using <code>alloca</code>.
 
 <p>For obvious reasons <code>strdupa</code> is implemented only as a macro;
 you cannot get the address of this function.  Despite this limitation
@@ -10189,28 +9900,27 @@
 
 <p>Please note that calling <code>strtok</code> using <var>path</var> directly is
 invalid.  It is also not allowed to call <code>strdupa</code> in the argument
 list of <code>strtok</code> since <code>strdupa</code> uses <code>alloca</code>
-(see <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>) can interfere with the parameter
+(see <a href="#Variable Size Automatic">Variable Size Automatic</a>) can interfere with the parameter
 passing.
 
 <p>This function is only available if GNU CC is used. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strndupa</b><i> (const char *<var>s</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>char * <b>strndupa</b><i> (const char *<var>s</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>strndup</code> but like <code>strdupa</code> it
 allocates the new string using <code>alloca</code>
-see <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>.  The same advantages and limitations
+see <a href="#Variable Size Automatic">Variable Size Automatic</a>.  The same advantages and limitations
 of <code>strdupa</code> are valid for <code>strndupa</code>, too.
 
 <p>This function is implemented only as a macro, just like <code>strdupa</code>. 
 Just as <code>strdupa</code> this macro also must not be used inside the
@@ -10220,16 +9930,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strcat</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>)
-</i></td>
+<td align="left"><code>char * <b>strcat</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strcat</code> function is similar to <code>strcpy</code>, except that the
 characters from <var>from</var> are concatenated or appended to the end of
 <var>to</var>, instead of overwriting it.  That is, the first character from
@@ -10249,16 +9958,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcscat</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcscat</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcscat</code> function is similar to <code>wcscpy</code>, except that the
 characters from <var>wfrom</var> are concatenated or appended to the end of
 <var>wto</var>, instead of overwriting it.  That is, the first character from
@@ -10402,16 +10110,15 @@
 be rewritten to take advantage of already calculated results.  Again: it
 is almost always unnecessary to use <code>strcat</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strncat</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>char * <b>strncat</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>strcat</code> except that not more than <var>size</var>
 characters from <var>from</var> are appended to the end of <var>to</var>.  A
 single null character is also always appended to <var>to</var>, so the total
@@ -10433,16 +10140,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcsncat</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcsncat</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>wcscat</code> except that not more than <var>size</var>
 characters from <var>from</var> are appended to the end of <var>to</var>.  A
 single null character is also always appended to <var>to</var>, so the total
@@ -10494,52 +10200,50 @@
 hello, wo
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>bcopy</b><i> (const void *<var>from</var>, void *<var>to</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void <b>bcopy</b><i> (const void *<var>from</var>, void *<var>to</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a partially obsolete alternative for <code>memmove</code>, derived from
 BSD.  Note that it is not quite equivalent to <code>memmove</code>, because the
 arguments are not in the same order and there is no return value. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>bzero</b><i> (void *<var>block</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void <b>bzero</b><i> (void *<var>block</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a partially obsolete alternative for <code>memset</code>, derived from
 BSD.  Note that it is not as general as <code>memset</code>, because the only
 value it can store is zero. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="String%2fArray%20Comparison">String/Array Comparison</a>,
-Next:<a rel=next accesskey=n href="#Collation%20Functions">Collation Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Copying%20and%20Concatenation">Copying and Concatenation</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="String%2fArray Comparison">String/Array Comparison</a>,
+Next:<a rel=next accesskey=n href="#Collation Functions">Collation Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Copying and Concatenation">Copying and Concatenation</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>String/Array Comparison</h3>
 
 <p>You can use the functions in this section to perform comparisons on the
 contents of strings and arrays.  As well as checking for equality, these
 functions can also be used as the ordering functions for sorting
-operations.  See <a href="#Searching%20and%20Sorting">Searching and Sorting</a>, for an example of this.
+operations.  See <a href="#Searching and Sorting">Searching and Sorting</a>, for an example of this.
 
 <p>Unlike most comparison operations in C, the string comparison functions
 return a nonzero value if the strings are <em>not</em> equivalent rather
 than if they are.  The sign of the value indicates the relative ordering
@@ -10553,16 +10257,15 @@
 
 <p>All of these functions are declared in the header file <code>string.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>memcmp</b><i> (const void *<var>a1</var>, const void *<var>a2</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>memcmp</b><i> (const void *<var>a1</var>, const void *<var>a2</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>memcmp</code> compares the <var>size</var> bytes of memory
 beginning at <var>a1</var> against the <var>size</var> bytes of memory beginning
 at <var>a2</var>.  The value returned has the same sign as the difference
@@ -10574,16 +10277,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wmemcmp</b><i> (const wchar_t *<var>a1</var>, const wchar_t *<var>a2</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>wmemcmp</b><i> (const wchar_t *<var>a1</var>, const wchar_t *<var>a2</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>wmemcmp</code> compares the <var>size</var> wide characters
 beginning at <var>a1</var> against the <var>size</var> wide characters beginning
 at <var>a2</var>.  The value returned is smaller than or larger than zero
@@ -10632,16 +10334,15 @@
 <p>you are better off writing a specialized comparison function to compare
 <code>struct foo</code> objects instead of comparing them with <code>memcmp</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>strcmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)
-</i></td>
+<td align="left"><code>int <b>strcmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strcmp</code> function compares the string <var>s1</var> against
 <var>s2</var>, returning a value that has the same sign as the difference
 between the first differing pair of characters (interpreted as
@@ -10659,16 +10360,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wcscmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>)
-</i></td>
+<td align="left"><code>int <b>wcscmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>wcscmp</code> function compares the wide character string <var>ws1</var>
 against <var>ws2</var>.  The value returned is smaller than or larger than zero
@@ -10687,16 +10387,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>strcasecmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)
-</i></td>
+<td align="left"><code>int <b>strcasecmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>strcmp</code>, except that differences in case are
 ignored.  How uppercase and lowercase characters are related is
 determined by the currently selected locale.  In the standard <code>"C"</code>
@@ -10707,16 +10406,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wcscasecmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_T *<var>ws2</var>)
-</i></td>
+<td align="left"><code>int <b>wcscasecmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_T *<var>ws2</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>wcscmp</code>, except that differences in case are
 ignored.  How uppercase and lowercase characters are related is
 determined by the currently selected locale.  In the standard <code>"C"</code>
@@ -10727,16 +10425,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>strncmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>strncmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is the similar to <code>strcmp</code>, except that no more than
 <var>size</var> wide characters are compared.  In other words, if the two
 strings are the same in their first <var>size</var> wide characters, the
@@ -10744,16 +10441,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wcsncmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>wcsncmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is the similar to <code>wcscmp</code>, except that no more than
 <var>size</var> wide characters are compared.  In other words, if the two
 strings are the same in their first <var>size</var> wide characters, the
@@ -10761,16 +10457,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>strncasecmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>, size_t <var>n</var>)
-</i></td>
+<td align="left"><code>int <b>strncasecmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>, size_t <var>n</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>strncmp</code>, except that differences in case
 are ignored.  Like <code>strcasecmp</code>, it is locale dependent how
 uppercase and lowercase characters are related.
@@ -10779,16 +10474,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wcsncasecmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>s2</var>, size_t <var>n</var>)
-</i></td>
+<td align="left"><code>int <b>wcsncasecmp</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>s2</var>, size_t <var>n</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>wcsncmp</code>, except that differences in case
 are ignored.  Like <code>wcscasecmp</code>, it is locale dependent how
 uppercase and lowercase characters are related.
@@ -10818,16 +10512,15 @@
     =&gt; 0    /* The initial 5 characters are the same. */
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>strverscmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)
-</i></td>
+<td align="left"><code>int <b>strverscmp</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strverscmp</code> function compares the string <var>s1</var> against
 <var>s2</var>, considering them as holding indices/version numbers.  Return
 value follows the same conventions as found in the <code>strverscmp</code>
@@ -10872,26 +10565,25 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>bcmp</b><i> (const void *<var>a1</var>, const void *<var>a2</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>bcmp</b><i> (const void *<var>a1</var>, const void *<var>a2</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an obsolete alias for <code>memcmp</code>, derived from BSD. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Collation%20Functions">Collation Functions</a>,
-Next:<a rel=next accesskey=n href="#Search%20Functions">Search Functions</a>,
-Previous:<a rel=previous accesskey=p href="#String%2fArray%20Comparison">String/Array Comparison</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="Collation Functions">Collation Functions</a>,
+Next:<a rel=next accesskey=n href="#Search Functions">Search Functions</a>,
+Previous:<a rel=previous accesskey=p href="#String%2fArray Comparison">String/Array Comparison</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Collation Functions</h3>
 
@@ -10927,32 +10619,30 @@
 transform all the strings just once, and subsequently compare the
 transformed strings with <code>strcmp</code> or <code>wcscmp</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>strcoll</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)
-</i></td>
+<td align="left"><code>int <b>strcoll</b><i> (const char *<var>s1</var>, const char *<var>s2</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strcoll</code> function is similar to <code>strcmp</code> but uses the
 collating sequence of the current locale for collation (the
 <code>LC_COLLATE</code> locale). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wcscoll</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>)
-</i></td>
+<td align="left"><code>int <b>wcscoll</b><i> (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcscoll</code> function is similar to <code>wcscmp</code> but uses the
 collating sequence of the current locale for collation (the
 <code>LC_COLLATE</code> locale). 
@@ -10960,9 +10650,9 @@
 </table>
 
 <p>Here is an example of sorting an array of strings, using <code>strcoll</code>
 to compare them.  The actual sort algorithm is not written here; it
-comes from <code>qsort</code> (see <a href="#Array%20Sort%20Function">Array Sort Function</a>).  The job of the
+comes from <code>qsort</code> (see <a href="#Array Sort Function">Array Sort Function</a>).  The job of the
 code shown here is to say how to compare the strings while sorting them. 
 (Later on in this section, we will show a way to do this more
 efficiently using <code>strxfrm</code>.)
 
@@ -10986,25 +10676,24 @@
 }
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>strxfrm</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>size_t <b>strxfrm</b><i> (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>strxfrm</code> transforms the string <var>from</var> using the
 collation transformation determined by the locale currently selected for
 collation, and stores the transformed string in the array <var>to</var>.  Up
 to <var>size</var> characters (including a terminating null character) are
 stored.
 
 <p>The behavior is undefined if the strings <var>to</var> and <var>from</var>
-overlap; see <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+overlap; see <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <p>The return value is the length of the entire transformed string.  This
 value is not affected by the value of <var>size</var>, but if it is greater
 or equal than <var>size</var>, it means that the transformed string did not
@@ -11023,25 +10712,24 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcsxfrm</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *<var>wfrom</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcsxfrm</b><i> (wchar_t *restrict <var>wto</var>, const wchar_t *<var>wfrom</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>wcsxfrm</code> transforms wide character string <var>wfrom</var>
 using the collation transformation determined by the locale currently
 selected for collation, and stores the transformed string in the array
 <var>wto</var>.  Up to <var>size</var> wide characters (including a terminating null
 character) are stored.
 
 <p>The behavior is undefined if the strings <var>wto</var> and <var>wfrom</var>
-overlap; see <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+overlap; see <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <p>The return value is the length of the entire transformed wide character
 string.  This value is not affected by the value of <var>size</var>, but if
 it is greater or equal than <var>size</var>, it means that the transformed
@@ -11173,12 +10861,12 @@
 feature of ISO&nbsp;C90.  Older C dialects have no equivalent feature. 
 The wide character versions were introduced in Amendment&nbsp;1 to ISO&nbsp;C90.
 
 <p><hr>
-Node:<a name="Search%20Functions">Search Functions</a>,
-Next:<a rel=next accesskey=n href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>,
-Previous:<a rel=previous accesskey=p href="#Collation%20Functions">Collation Functions</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="Search Functions">Search Functions</a>,
+Next:<a rel=next accesskey=n href="#Finding Tokens in a String">Finding Tokens in a String</a>,
+Previous:<a rel=previous accesskey=p href="#Collation Functions">Collation Functions</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Search Functions</h3>
 
@@ -11186,16 +10874,15 @@
 of searching operations on strings and arrays.  These functions are
 declared in the header file <code>string.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memchr</b><i> (const void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>memchr</b><i> (const void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function finds the first occurrence of the byte <var>c</var> (converted
 to an <code>unsigned char</code>) in the initial <var>size</var> bytes of the
 object beginning at <var>block</var>.  The return value is a pointer to the
@@ -11203,16 +10890,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wmemchr</b><i> (const wchar_t *<var>block</var>, wchar_t <var>wc</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wmemchr</b><i> (const wchar_t *<var>block</var>, wchar_t <var>wc</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function finds the first occurrence of the wide character <var>wc</var>
 in the initial <var>size</var> wide characters of the object beginning at
 <var>block</var>.  The return value is a pointer to the located wide
@@ -11220,16 +10906,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>rawmemchr</b><i> (const void *<var>block</var>, int <var>c</var>)
-</i></td>
+<td align="left"><code>void * <b>rawmemchr</b><i> (const void *<var>block</var>, int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Often the <code>memchr</code> function is used with the knowledge that the
 byte <var>c</var> is available in the memory block specified by the
 parameters.  But this means that the <var>size</var> parameter is not really
@@ -11256,32 +10941,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memrchr</b><i> (const void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>memrchr</b><i> (const void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>memrchr</code> is like <code>memchr</code>, except that it searches
 backwards from the end of the block defined by <var>block</var> and <var>size</var>
 (instead of forwards from the front). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strchr</b><i> (const char *<var>string</var>, int <var>c</var>)
-</i></td>
+<td align="left"><code>char * <b>strchr</b><i> (const char *<var>string</var>, int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strchr</code> function finds the first occurrence of the character
 <var>c</var> (converted to a <code>char</code>) in the null-terminated string
 beginning at <var>string</var>.  The return value is a pointer to the located
@@ -11302,16 +10985,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcschr</b><i> (const wchar_t *<var>wstring</var>, int <var>wc</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcschr</b><i> (const wchar_t *<var>wstring</var>, int <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcschr</code> function finds the first occurrence of the wide
 character <var>wc</var> in the null-terminated wide character string
 beginning at <var>wstring</var>.  The return value is a pointer to the
@@ -11325,16 +11007,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strchrnul</b><i> (const char *<var>string</var>, int <var>c</var>)
-</i></td>
+<td align="left"><code>char * <b>strchrnul</b><i> (const char *<var>string</var>, int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>strchrnul</code> is the same as <code>strchr</code> except that if it does
 not find the character, it returns a pointer to string's terminating
 null character rather than a null pointer.
@@ -11343,16 +11024,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcschrnul</b><i> (const wchar_t *<var>wstring</var>, wchar_t <var>wc</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcschrnul</b><i> (const wchar_t *<var>wstring</var>, wchar_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>wcschrnul</code> is the same as <code>wcschr</code> except that if it does not
 find the wide character, it returns a pointer to wide character string's
 terminating null wide character rather than a null pointer.
@@ -11383,16 +11063,15 @@
 <code>strchr</code> is optimized in a special way so that <code>strchr</code>
 actually is faster.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strrchr</b><i> (const char *<var>string</var>, int <var>c</var>)
-</i></td>
+<td align="left"><code>char * <b>strrchr</b><i> (const char *<var>string</var>, int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>strrchr</code> is like <code>strchr</code>, except that it searches
 backwards from the end of the string <var>string</var> (instead of forwards
 from the front).
@@ -11404,32 +11083,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcsrchr</b><i> (const wchar_t *<var>wstring</var>, wchar_t <var>c</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcsrchr</b><i> (const wchar_t *<var>wstring</var>, wchar_t <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>wcsrchr</code> is like <code>wcschr</code>, except that it searches
 backwards from the end of the string <var>wstring</var> (instead of forwards
 from the front). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strstr</b><i> (const char *<var>haystack</var>, const char *<var>needle</var>)
-</i></td>
+<td align="left"><code>char * <b>strstr</b><i> (const char *<var>haystack</var>, const char *<var>needle</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>strchr</code>, except that it searches <var>haystack</var> for a
 substring <var>needle</var> rather than just a single character.  It
 returns a pointer into the string <var>haystack</var> that is the first
@@ -11445,16 +11122,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcsstr</b><i> (const wchar_t *<var>haystack</var>, const wchar_t *<var>needle</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcsstr</b><i> (const wchar_t *<var>haystack</var>, const wchar_t *<var>needle</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>wcschr</code>, except that it searches <var>haystack</var> for a
 substring <var>needle</var> rather than just a single wide character.  It
 returns a pointer into the string <var>haystack</var> that is the first wide
@@ -11463,32 +11139,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcswcs</b><i> (const wchar_t *<var>haystack</var>, const wchar_t *<var>needle</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcswcs</b><i> (const wchar_t *<var>haystack</var>, const wchar_t *<var>needle</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>wcsstr</code> is an depricated alias for <code>wcsstr</code>.  This is the
 name originally used in the X/Open Portability Guide before the
 Amendment&nbsp;1 to ISO&nbsp;C90 was published. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strcasestr</b><i> (const char *<var>haystack</var>, const char *<var>needle</var>)
-</i></td>
+<td align="left"><code>char * <b>strcasestr</b><i> (const char *<var>haystack</var>, const char *<var>needle</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>strstr</code>, except that it ignores case in searching for
 the substring.   Like <code>strcasecmp</code>, it is locale dependent how
 uppercase and lowercase characters are related.
@@ -11502,16 +11176,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memmem</b><i> (const void *<var>haystack</var>, size_t <var>haystack-len</var>,<br>const void *<var>needle</var>, size_t <var>needle-len</var>)
-</i></td>
+<td align="left"><code>void * <b>memmem</b><i> (const void *<var>haystack</var>, size_t <var>haystack-len</var>,<br>const void *<var>needle</var>, size_t <var>needle-len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>strstr</code>, but <var>needle</var> and <var>haystack</var> are byte
 arrays rather than null-terminated strings.  <var>needle-len</var> is the
 length of <var>needle</var> and <var>haystack-len</var> is the length of
@@ -11521,16 +11194,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>strspn</b><i> (const char *<var>string</var>, const char *<var>skipset</var>)
-</i></td>
+<td align="left"><code>size_t <b>strspn</b><i> (const char *<var>string</var>, const char *<var>skipset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strspn</code> ("string span") function returns the length of the
 initial substring of <var>string</var> that consists entirely of characters that
 are members of the set specified by the string <var>skipset</var>.  The order
@@ -11548,16 +11220,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcsspn</b><i> (const wchar_t *<var>wstring</var>, const wchar_t *<var>skipset</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcsspn</b><i> (const wchar_t *<var>wstring</var>, const wchar_t *<var>skipset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcsspn</code> ("wide character string span") function returns the
 length of the initial substring of <var>wstring</var> that consists entirely
 of wide characters that are members of the set specified by the string
@@ -11566,16 +11237,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>strcspn</b><i> (const char *<var>string</var>, const char *<var>stopset</var>)
-</i></td>
+<td align="left"><code>size_t <b>strcspn</b><i> (const char *<var>string</var>, const char *<var>stopset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strcspn</code> ("string complement span") function returns the length
 of the initial substring of <var>string</var> that consists entirely of characters
 that are <em>not</em> members of the set specified by the string <var>stopset</var>. 
@@ -11594,16 +11264,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcscspn</b><i> (const wchar_t *<var>wstring</var>, const wchar_t *<var>stopset</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcscspn</b><i> (const wchar_t *<var>wstring</var>, const wchar_t *<var>stopset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcscspn</code> ("wide character string complement span") function
 returns the length of the initial substring of <var>wstring</var> that
 consists entirely of wide characters that are <em>not</em> members of the
@@ -11613,16 +11282,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strpbrk</b><i> (const char *<var>string</var>, const char *<var>stopset</var>)
-</i></td>
+<td align="left"><code>char * <b>strpbrk</b><i> (const char *<var>string</var>, const char *<var>stopset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strpbrk</code> ("string pointer break") function is related to
 <code>strcspn</code>, except that it returns a pointer to the first character
 in <var>string</var> that is a member of the set <var>stopset</var> instead of the
@@ -11642,16 +11310,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcspbrk</b><i> (const wchar_t *<var>wstring</var>, const wchar_t *<var>stopset</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcspbrk</b><i> (const wchar_t *<var>wstring</var>, const wchar_t *<var>stopset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcspbrk</code> ("wide character string pointer break") function is
 related to <code>wcscspn</code>, except that it returns a pointer to the first
 wide character in <var>wstring</var> that is a member of the set
@@ -11662,16 +11329,15 @@
 
 <h4>Compatibility String Search Functions</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>index</b><i> (const char *<var>string</var>, int <var>c</var>)
-</i></td>
+<td align="left"><code>char * <b>index</b><i> (const char *<var>string</var>, int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>index</code> is another name for <code>strchr</code>; they are exactly the same. 
 New code should always use <code>strchr</code> since this name is defined in
 ISO&nbsp;C while <code>index</code> is a BSD invention which never was available
@@ -11679,16 +11345,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>rindex</b><i> (const char *<var>string</var>, int <var>c</var>)
-</i></td>
+<td align="left"><code>char * <b>rindex</b><i> (const char *<var>string</var>, int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>rindex</code> is another name for <code>strrchr</code>; they are exactly the same. 
 New code should always use <code>strrchr</code> since this name is defined in
 ISO&nbsp;C while <code>rindex</code> is a BSD invention which never was available
@@ -11696,12 +11361,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>,
+Node:<a name="Finding Tokens in a String">Finding Tokens in a String</a>,
 Next:<a rel=next accesskey=n href="#strfry">strfry</a>,
-Previous:<a rel=previous accesskey=p href="#Search%20Functions">Search Functions</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Previous:<a rel=previous accesskey=p href="#Search Functions">Search Functions</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Finding Tokens in a String</h3>
 
@@ -11710,16 +11375,15 @@
 into tokens.  You can do this with the <code>strtok</code> function, declared
 in the header file <code>string.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strtok</b><i> (char *restrict <var>newstring</var>, const char *restrict <var>delimiters</var>)
-</i></td>
+<td align="left"><code>char * <b>strtok</b><i> (char *restrict <var>newstring</var>, const char *restrict <var>delimiters</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A string can be split into tokens by making a series of calls to the
 function <code>strtok</code>.
 
@@ -11762,16 +11426,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>wcstok</b><i> (wchar_t *<var>newstring</var>, const char *<var>delimiters</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>wcstok</b><i> (wchar_t *<var>newstring</var>, const char *<var>delimiters</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A string can be split into tokens by making a series of calls to the
 function <code>wcstok</code>.
 
@@ -11812,17 +11475,17 @@
 </table>
 
 <p><strong>Warning:</strong> Since <code>strtok</code> and <code>wcstok</code> alter the string
 they is parsing, you should always copy the string to a temporary buffer
-before parsing it with <code>strtok</code>/<code>wcstok</code> (see <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>).  If you allow <code>strtok</code> or <code>wcstok</code> to modify
+before parsing it with <code>strtok</code>/<code>wcstok</code> (see <a href="#Copying and Concatenation">Copying and Concatenation</a>).  If you allow <code>strtok</code> or <code>wcstok</code> to modify
 a string that came from another part of your program, you are asking for
 trouble; that string might be used for other purposes after
 <code>strtok</code> or <code>wcstok</code> has modified it, and it would not have
 the expected value.
 
 <p>The string that you are operating on might even be a constant.  Then
 when <code>strtok</code> or <code>wcstok</code> tries to modify it, your program
-will get a fatal signal for writing in read-only memory.  See <a href="#Program%20Error%20Signals">Program Error Signals</a>.  Even if the operation of <code>strtok</code> or <code>wcstok</code>
+will get a fatal signal for writing in read-only memory.  See <a href="#Program Error Signals">Program Error Signals</a>.  Even if the operation of <code>strtok</code> or <code>wcstok</code>
 would not require a modification of the string (e.g., if there is
 exactly one token) the string can (and in the GNU libc case will) be
 modified.
 
@@ -11862,16 +11525,15 @@
 which overcome the limitation of non-reentrancy.  They are only
 available for multibyte character strings.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strtok_r</b><i> (char *<var>newstring</var>, const char *<var>delimiters</var>, char **<var>save_ptr</var>)
-</i></td>
+<td align="left"><code>char * <b>strtok_r</b><i> (char *<var>newstring</var>, const char *<var>delimiters</var>, char **<var>save_ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Just like <code>strtok</code>, this function splits the string into several
 tokens which can be accessed by successive calls to <code>strtok_r</code>. 
 The difference is that the information about the next token is stored in
@@ -11885,16 +11547,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strsep</b><i> (char **<var>string_ptr</var>, const char *<var>delimiter</var>)
-</i></td>
+<td align="left"><code>char * <b>strsep</b><i> (char **<var>string_ptr</var>, const char *<var>delimiter</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function has a similar functionality as <code>strtok_r</code> with the
 <var>newstring</var> argument replaced by the <var>save_ptr</var> argument.  The
 initialization of the moving pointer has to be done by the user. 
@@ -11942,16 +11603,15 @@
 token = strsep (&amp;running, delimiters);    /* token =&gt; NULL */
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>basename</b><i> (const char *<var>filename</var>)
-</i></td>
+<td align="left"><code>char * <b>basename</b><i> (const char *<var>filename</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The GNU version of the <code>basename</code> function returns the last
 component of the path in <var>filename</var>.  This function is the preferred
 usage, since it does not modify the argument, <var>filename</var>, and
@@ -11984,16 +11644,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>basename</b><i> (char *<var>path</var>)
-</i></td>
+<td align="left"><code>char * <b>basename</b><i> (char *<var>path</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the standard XPG defined <code>basename</code>. It is similar in
 spirit to the GNU version, but may modify the <var>path</var> by removing
 trailing '/' characters.  If the <var>path</var> is made up entirely of '/'
@@ -12026,16 +11685,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>dirname</b><i> (char *<var>path</var>)
-</i></td>
+<td align="left"><code>char * <b>dirname</b><i> (char *<var>path</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>dirname</code> function is the compliment to the XPG version of
 <code>basename</code>.  It returns the parent directory of the file specified
 by <var>path</var>.  If <var>path</var> is <code>NULL</code>, an empty string, or
@@ -12045,11 +11703,11 @@
 </table>
 
 <p><hr>
 Node:<a name="strfry">strfry</a>,
-Next:<a rel=next accesskey=n href="#Trivial%20Encryption">Trivial Encryption</a>,
-Previous:<a rel=previous accesskey=p href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Next:<a rel=next accesskey=n href="#Trivial Encryption">Trivial Encryption</a>,
+Previous:<a rel=previous accesskey=p href="#Finding Tokens in a String">Finding Tokens in a String</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>strfry</h3>
 
@@ -12062,16 +11720,15 @@
 
 <p>The prototype for this function is in <code>string.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strfry</b><i> (char *<var>string</var>)
-</i></td>
+<td align="left"><code>char * <b>strfry</b><i> (char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>strfry</code> creates a pseudorandom anagram of a string, replacing the
 input with the anagram in place.  For each position in the string,
@@ -12085,12 +11742,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Trivial%20Encryption">Trivial Encryption</a>,
-Next:<a rel=next accesskey=n href="#Encode%20Binary%20Data">Encode Binary Data</a>,
+Node:<a name="Trivial Encryption">Trivial Encryption</a>,
+Next:<a rel=next accesskey=n href="#Encode Binary Data">Encode Binary Data</a>,
 Previous:<a rel=previous accesskey=p href="#strfry">strfry</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Trivial Encryption</h3>
 
@@ -12101,21 +11758,20 @@
 method for obscuring offensive jokes from sensitive eyes and such. 
 Unlike Rot13, <code>memfrob</code> works on arbitrary binary data, not just
 text.
 
-<p>For true encryption, See <a href="#Cryptographic%20Functions">Cryptographic Functions</a>.
+<p>For true encryption, See <a href="#Cryptographic Functions">Cryptographic Functions</a>.
 
 <p>This function is declared in <code>string.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>memfrob</b><i> (void *<var>mem</var>, size_t <var>length</var>)
-</i></td>
+<td align="left"><code>void * <b>memfrob</b><i> (void *<var>mem</var>, size_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>memfrob</code> transforms (frobnicates) each byte of the data structure
 at <var>mem</var>, which is <var>length</var> bytes long, by bitwise exclusive
@@ -12127,20 +11783,20 @@
 
 <p>This is a good function for hiding information from someone who doesn't
 want to see it or doesn't want to see it very much.  To really prevent
 people from retrieving the information, use stronger encryption such as
-that described in See <a href="#Cryptographic%20Functions">Cryptographic Functions</a>.
+that described in See <a href="#Cryptographic Functions">Cryptographic Functions</a>.
 
 <p><strong>Portability Note:</strong>  This function is unique to the GNU C library.
 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Encode%20Binary%20Data">Encode Binary Data</a>,
-Next:<a rel=next accesskey=n href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>,
-Previous:<a rel=previous accesskey=p href="#Trivial%20Encryption">Trivial Encryption</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="Encode Binary Data">Encode Binary Data</a>,
+Next:<a rel=next accesskey=n href="#Argz and Envz Vectors">Argz and Envz Vectors</a>,
+Previous:<a rel=previous accesskey=p href="#Trivial Encryption">Trivial Encryption</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Encode Binary Data</h3>
 
@@ -12150,16 +11806,15 @@
 systems (and nowadays XPG compliant systems) provide minimal support for
 this task.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>l64a</b><i> (long int <var>n</var>)
-</i></td>
+<td align="left"><code>char * <b>l64a</b><i> (long int <var>n</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function encodes a 32-bit input value using characters from the
 basic character set.  It returns a pointer to a 6 character buffer which
 contains an encoded version of <var>n</var>.  To encode a series of bytes the
@@ -12187,9 +11842,9 @@
   char *out = malloc (6 + ((len + 3) / 4) * 6 + 1);
   char *cp = out;
 
   /* Encode the length. */
-  /* Using `htonl' is necessary so that the data can be
+  /* Using 'htonl' is necessary so that the data can be
      decoded even on machines with different byte order. */
 
   cp = mempcpy (cp, l64a (htonl (len)), 6);
 
@@ -12202,9 +11857,9 @@
       len -= 4;
       if (n)
         cp = mempcpy (cp, l64a (htonl (n)), 6);
       else
-            /* `l64a' returns the empty string for n==0, so we 
+            /* 'l64a' returns the empty string for n==0, so we 
                must generate its encoding ("......") by hand. */
         cp = stpcpy (cp, "......");
     }
   if (len &gt; 0)
@@ -12233,16 +11888,15 @@
 <p>To decode data produced with <code>l64a</code> the following function should be
 used.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>a64l</b><i> (const char *<var>string</var>)
-</i></td>
+<td align="left"><code>long int <b>a64l</b><i> (const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The parameter <var>string</var> should contain a string which was produced by
 a call to <code>l64a</code>.  The function processes at least 6 characters of
 this string, and decodes the characters it finds according to the table
@@ -12281,11 +11935,11 @@
 methods which are much more widely used (UU encoding, MIME encoding). 
 Generally, it is better to use one of these encodings.
 
 <p><hr>
-Node:<a name="Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>,
-Previous:<a rel=previous accesskey=p href="#Encode%20Binary%20Data">Encode Binary Data</a>,
-Up:<a rel=up accesskey=u href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
+Node:<a name="Argz and Envz Vectors">Argz and Envz Vectors</a>,
+Previous:<a rel=previous accesskey=p href="#Encode Binary Data">Encode Binary Data</a>,
+Up:<a rel=up accesskey=u href="#String and Array Utilities">String and Array Utilities</a>
 <br>
 
 <h3>Argz and Envz Vectors</h3>
 
@@ -12297,16 +11951,16 @@
 name-value pair, separated by a <code>'='</code> character (as in a Unix
 environment).
 
 <ul>
-<li><a accesskey=1 href="#Argz%20Functions">Argz Functions</a>:               Operations on argz vectors. 
-<li><a accesskey=2 href="#Envz%20Functions">Envz Functions</a>:               Additional operations on environment vectors. 
+<li><a accesskey=1 href="#Argz Functions">Argz Functions</a>:               Operations on argz vectors. 
+<li><a accesskey=2 href="#Envz Functions">Envz Functions</a>:               Additional operations on environment vectors. 
 </ul>
 
 <p><hr>
-Node:<a name="Argz%20Functions">Argz Functions</a>,
-Next:<a rel=next accesskey=n href="#Envz%20Functions">Envz Functions</a>,
-Up:<a rel=up accesskey=u href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
+Node:<a name="Argz Functions">Argz Functions</a>,
+Next:<a rel=next accesskey=n href="#Envz Functions">Envz Functions</a>,
+Up:<a rel=up accesskey=u href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
 <br>
 
 <h4>Argz Functions</h4>
 
@@ -12321,42 +11975,40 @@
 be freed by using <code>free</code>; conversely, any argz function that may
 grow a string expects that string to have been allocated using
 <code>malloc</code> (those argz functions that only examine their arguments or
 modify them in place will work on any sort of memory). 
-See <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>.
+See <a href="#Unconstrained Allocation">Unconstrained Allocation</a>.
 
 <p>All argz functions that do memory allocation have a return type of
 <code>error_t</code>, and return <code>0</code> for success, and <code>ENOMEM</code> if an
 allocation error occurs.
 
 <p>These functions are declared in the standard include file <code>argz.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_create</b><i> (char *const <var>argv</var>[], char **<var>argz</var>, size_t *<var>argz_len</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_create</b><i> (char *const <var>argv</var>[], char **<var>argz</var>, size_t *<var>argz_len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_create</code> function converts the Unix-style argument vector
 <var>argv</var> (a vector of pointers to normal C strings, terminated by
-<code>(char *)0</code>; see <a href="#Program%20Arguments">Program Arguments</a>) into an argz vector with
+<code>(char *)0</code>; see <a href="#Program Arguments">Program Arguments</a>) into an argz vector with
 the same elements, which is returned in <var>argz</var> and <var>argz_len</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_create_sep</b><i> (const char *<var>string</var>, int <var>sep</var>, char **<var>argz</var>, size_t *<var>argz_len</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_create_sep</b><i> (const char *<var>string</var>, int <var>sep</var>, char **<var>argz</var>, size_t *<var>argz_len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_create_sep</code> function converts the null-terminated string
 <var>string</var> into an argz vector (returned in <var>argz</var> and
 <var>argz_len</var>) by splitting it into elements at every occurrence of the
@@ -12364,31 +12016,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>argz_count</b><i> (const char *<var>argz</var>, size_t <var>arg_len</var>)
-</i></td>
+<td align="left"><code>size_t <b>argz_count</b><i> (const char *<var>argz</var>, size_t <var>arg_len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns the number of elements in the argz vector <var>argz</var> and
 <var>argz_len</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>argz_extract</b><i> (char *<var>argz</var>, size_t <var>argz_len</var>, char **<var>argv</var>)
-</i></td>
+<td align="left"><code>void <b>argz_extract</b><i> (char *<var>argz</var>, size_t <var>argz_len</var>, char **<var>argv</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_extract</code> function converts the argz vector <var>argz</var> and
 <var>argz_len</var> into a Unix-style argument vector stored in <var>argv</var>,
 by putting pointers to every element in <var>argz</var> into successive
@@ -12399,21 +12049,20 @@
 bytes should be enough).  Note that the string pointers stored into
 <var>argv</var> point into <var>argz</var>--they are not copies--and so
 <var>argz</var> must be copied if it will be changed while <var>argv</var> is
 still active.  This function is useful for passing the elements in
-<var>argz</var> to an exec function (see <a href="#Executing%20a%20File">Executing a File</a>). 
+<var>argz</var> to an exec function (see <a href="#Executing a File">Executing a File</a>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>argz_stringify</b><i> (char *<var>argz</var>, size_t <var>len</var>, int <var>sep</var>)
-</i></td>
+<td align="left"><code>void <b>argz_stringify</b><i> (char *<var>argz</var>, size_t <var>len</var>, int <var>sep</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_stringify</code> converts <var>argz</var> into a normal string with
 the elements separated by the character <var>sep</var>, by replacing each
 <code>'\0'</code> inside <var>argz</var> (except the last one, which terminates the
@@ -12422,32 +12071,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_add</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>str</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_add</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>str</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_add</code> function adds the string <var>str</var> to the end of the
 argz vector <code>*<var>argz</var></code>, and updates <code>*<var>argz</var></code> and
 <code>*<var>argz_len</var></code> accordingly. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_add_sep</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>str</var>, int <var>delim</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_add_sep</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>str</var>, int <var>delim</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_add_sep</code> function is similar to <code>argz_add</code>, but
 <var>str</var> is split into separate elements in the result at occurrences of
 the character <var>delim</var>.  This is useful, for instance, for
@@ -12456,16 +12103,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_append</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>buf</var>, size_t <var>buf_len</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_append</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>buf</var>, size_t <var>buf_len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_append</code> function appends <var>buf_len</var> bytes starting at
 <var>buf</var> to the argz vector <code>*<var>argz</var></code>, reallocating
 <code>*<var>argz</var></code> to accommodate it, and adding <var>buf_len</var> to
@@ -12473,16 +12119,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_delete</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, char *<var>entry</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_delete</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, char *<var>entry</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>entry</var> points to the beginning of one of the elements in the
 argz vector <code>*<var>argz</var></code>, the <code>argz_delete</code> function will
 remove this entry and reallocate <code>*<var>argz</var></code>, modifying
@@ -12492,16 +12137,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_insert</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, char *<var>before</var>, const char *<var>entry</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_insert</b><i> (char **<var>argz</var>, size_t *<var>argz_len</var>, char *<var>before</var>, const char *<var>entry</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_insert</code> function inserts the string <var>entry</var> into the
 argz vector <code>*<var>argz</var></code> at a point just before the existing
 element pointed to by <var>before</var>, reallocating <code>*<var>argz</var></code> and
@@ -12513,16 +12157,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>argz_next</b><i> (char *<var>argz</var>, size_t <var>argz_len</var>, const char *<var>entry</var>)
-</i></td>
+<td align="left"><code>char * <b>argz_next</b><i> (char *<var>argz</var>, size_t <var>argz_len</var>, const char *<var>entry</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argz_next</code> function provides a convenient way of iterating
 over the elements in the argz vector <var>argz</var>.  It returns a pointer
 to the next element in <var>argz</var> after the element <var>entry</var>, or
@@ -12552,16 +12195,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argz_replace</b><i> (char&nbsp;**<var>argz</var>,&nbsp;size_t&nbsp;*<var>argz_len</var>, const&nbsp;char&nbsp;*<var>str</var>,&nbsp;const&nbsp;char&nbsp;*<var>with</var>, unsigned&nbsp;*<var>replace_count</var>)
-</i></td>
+<td align="left"><code>error_t <b>argz_replace</b><i> (char&nbsp;**<var>argz</var>,&nbsp;size_t&nbsp;*<var>argz_len</var>, const&nbsp;char&nbsp;*<var>str</var>,&nbsp;const&nbsp;char&nbsp;*<var>with</var>, unsigned&nbsp;*<var>replace_count</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Replace any occurrences of the string <var>str</var> in <var>argz</var> with
 <var>with</var>, reallocating <var>argz</var> as necessary.  If
 <var>replace_count</var> is non-zero, <code>*<var>replace_count</var></code> will be
@@ -12569,11 +12211,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Envz%20Functions">Envz Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Argz%20Functions">Argz Functions</a>,
-Up:<a rel=up accesskey=u href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
+Node:<a name="Envz Functions">Envz Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Argz Functions">Argz Functions</a>,
+Up:<a rel=up accesskey=u href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
 <br>
 
 <h4>Envz Functions</h4>
 
@@ -12599,16 +12241,15 @@
 
 <p>These functions are declared in the standard include file <code>envz.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>envz_entry</b><i> (const char *<var>envz</var>, size_t <var>envz_len</var>, const char *<var>name</var>)
-</i></td>
+<td align="left"><code>char * <b>envz_entry</b><i> (const char *<var>envz</var>, size_t <var>envz_len</var>, const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>envz_entry</code> function finds the entry in <var>envz</var> with the name
 <var>name</var>, and returns a pointer to the whole entry--that is, the argz
 element which begins with <var>name</var> followed by a <code>'='</code> character.  If
@@ -12616,16 +12257,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>envz_get</b><i> (const char *<var>envz</var>, size_t <var>envz_len</var>, const char *<var>name</var>)
-</i></td>
+<td align="left"><code>char * <b>envz_get</b><i> (const char *<var>envz</var>, size_t <var>envz_len</var>, const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>envz_get</code> function finds the entry in <var>envz</var> with the name
 <var>name</var> (like <code>envz_entry</code>), and returns a pointer to the value
 portion of that entry (following the <code>'='</code>).  If there is no entry with
@@ -12633,16 +12273,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>envz_add</b><i> (char **<var>envz</var>, size_t *<var>envz_len</var>, const char *<var>name</var>, const char *<var>value</var>)
-</i></td>
+<td align="left"><code>error_t <b>envz_add</b><i> (char **<var>envz</var>, size_t *<var>envz_len</var>, const char *<var>name</var>, const char *<var>value</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>envz_add</code> function adds an entry to <code>*<var>envz</var></code>
 (updating <code>*<var>envz</var></code> and <code>*<var>envz_len</var></code>) with the name
 <var>name</var>, and value <var>value</var>.  If an entry with the same name
@@ -12652,16 +12291,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>envz_merge</b><i> (char **<var>envz</var>, size_t *<var>envz_len</var>, const char *<var>envz2</var>, size_t <var>envz2_len</var>, int <var>override</var>)
-</i></td>
+<td align="left"><code>error_t <b>envz_merge</b><i> (char **<var>envz</var>, size_t *<var>envz_len</var>, const char *<var>envz2</var>, size_t <var>envz2_len</var>, int <var>override</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>envz_merge</code> function adds each entry in <var>envz2</var> to <var>envz</var>,
 as if with <code>envz_add</code>, updating <code>*<var>envz</var></code> and
 <code>*<var>envz_len</var></code>.  If <var>override</var> is true, then values in <var>envz2</var>
@@ -12673,26 +12311,25 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>envz_strip</b><i> (char **<var>envz</var>, size_t *<var>envz_len</var>)
-</i></td>
+<td align="left"><code>void <b>envz_strip</b><i> (char **<var>envz</var>, size_t *<var>envz_len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>envz_strip</code> function removes any null entries from <var>envz</var>,
 updating <code>*<var>envz</var></code> and <code>*<var>envz_len</var></code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Character%20Set%20Handling">Character Set Handling</a>,
+Node:<a name="Character Set Handling">Character Set Handling</a>,
 Next:<a rel=next accesskey=n href="#Locales">Locales</a>,
-Previous:<a rel=previous accesskey=p href="#String%20and%20Array%20Utilities">String and Array Utilities</a>,
+Previous:<a rel=previous accesskey=p href="#String and Array Utilities">String and Array Utilities</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Character Set Handling</h2>
@@ -12706,21 +12343,21 @@
 choices.  This chapter shows the functionality that was added to the C
 library to support multiple character sets.
 
 <ul>
-<li><a accesskey=1 href="#Extended%20Char%20Intro">Extended Char Intro</a>:               Introduction to Extended Characters. 
-<li><a accesskey=2 href="#Charset%20Function%20Overview">Charset Function Overview</a>:         Overview about Character Handling
+<li><a accesskey=1 href="#Extended Char Intro">Extended Char Intro</a>:               Introduction to Extended Characters. 
+<li><a accesskey=2 href="#Charset Function Overview">Charset Function Overview</a>:         Overview about Character Handling
                                       Functions. 
-<li><a accesskey=3 href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>:  Restartable multibyte conversion
+<li><a accesskey=3 href="#Restartable multibyte conversion">Restartable multibyte conversion</a>:  Restartable multibyte conversion
                                       Functions. 
-<li><a accesskey=4 href="#Non-reentrant%20Conversion">Non-reentrant Conversion</a>:          Non-reentrant Conversion Function. 
-<li><a accesskey=5 href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>:        Generic Charset Conversion. 
+<li><a accesskey=4 href="#Non-reentrant Conversion">Non-reentrant Conversion</a>:          Non-reentrant Conversion Function. 
+<li><a accesskey=5 href="#Generic Charset Conversion">Generic Charset Conversion</a>:        Generic Charset Conversion. 
 </ul>
 
 <p><hr>
-Node:<a name="Extended%20Char%20Intro">Extended Char Intro</a>,
-Next:<a rel=next accesskey=n href="#Charset%20Function%20Overview">Charset Function Overview</a>,
-Up:<a rel=up accesskey=u href="#Character%20Set%20Handling">Character Set Handling</a>
+Node:<a name="Extended Char Intro">Extended Char Intro</a>,
+Next:<a rel=next accesskey=n href="#Charset Function Overview">Charset Function Overview</a>,
+Up:<a rel=up accesskey=u href="#Character Set Handling">Character Set Handling</a>
 <br>
 
 <h3>Introduction to Extended Characters</h3>
 
@@ -12782,16 +12419,15 @@
 the similarity there is also a type corresponding to <code>int</code> for
 those functions that take a single wide character.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>wchar_t</b><i>
-</i></td>
+<td align="left"><code><b>wchar_t</b><i></i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used as the base type for wide character strings. 
 In other words, arrays of objects of this type are the equivalent of
 <code>char[]</code> for multibyte character strings.  The type is defined in
@@ -12815,16 +12451,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>wint_t</b><i>
-</i></td>
+<td align="left"><code><b>wint_t</b><i></i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>wint_t</code> is a data type used for parameters and variables that
 contain a single wide character.  As the name suggests this type is the
 equivalent of <code>int</code> when using the normal <code>char</code> strings.  The
@@ -12842,16 +12477,15 @@
 specifying the minimum and maximum value representable in an object of
 type <code>wchar_t</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>WCHAR_MIN</b><i>
-</i></td>
+<td align="left"><code>wint_t <b>WCHAR_MIN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The macro <code>WCHAR_MIN</code> evaluates to the minimum value representable
 by an object of type <code>wint_t</code>.
 
@@ -12859,16 +12493,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>WCHAR_MAX</b><i>
-</i></td>
+<td align="left"><code>wint_t <b>WCHAR_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The macro <code>WCHAR_MAX</code> evaluates to the maximum value representable
 by an object of type <code>wint_t</code>.
 
@@ -12878,16 +12511,15 @@
 
 <p>Another special wide character value is the equivalent to <code>EOF</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>WEOF</b><i>
-</i></td>
+<td align="left"><code>wint_t <b>WEOF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The macro <code>WEOF</code> evaluates to a constant expression of type
 <code>wint_t</code> whose value is different from any member of the extended
 character set.
@@ -12978,9 +12610,9 @@
 Roman alphabet lead to character sets like ISO&nbsp;6937.  Here bytes
 representing characters like the acute accent do not produce output
 themselves: one has to combine them with other characters to get the
 desired result.  For example, the byte sequence <code>0xc2 0x61</code>
-(non-spacing acute accent, followed by lower-case `a') to get the "small
+(non-spacing acute accent, followed by lower-case 'a') to get the "small
 a with  acute" character.  To get the acute accent character on its own,
 one has to write <code>0xc2 0x20</code> (the non-spacing acute followed by a
 space).
 
@@ -13030,12 +12662,12 @@
 provided by the C library to handle wide character strings there should
 be no compatibility problems with other systems.
 
 <p><hr>
-Node:<a name="Charset%20Function%20Overview">Charset Function Overview</a>,
-Next:<a rel=next accesskey=n href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Extended%20Char%20Intro">Extended Char Intro</a>,
-Up:<a rel=up accesskey=u href="#Character%20Set%20Handling">Character Set Handling</a>
+Node:<a name="Charset Function Overview">Charset Function Overview</a>,
+Next:<a rel=next accesskey=n href="#Restartable multibyte conversion">Restartable multibyte conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Extended Char Intro">Extended Char Intro</a>,
+Up:<a rel=up accesskey=u href="#Character Set Handling">Character Set Handling</a>
 <br>
 
 <h3>Overview about Character Handling Functions</h3>
 
@@ -13053,12 +12685,12 @@
 But we will start with the functions defined in Amendment&nbsp;1 to
 ISO&nbsp;C90.
 
 <p><hr>
-Node:<a name="Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>,
-Next:<a rel=next accesskey=n href="#Non-reentrant%20Conversion">Non-reentrant Conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Charset%20Function%20Overview">Charset Function Overview</a>,
-Up:<a rel=up accesskey=u href="#Character%20Set%20Handling">Character Set Handling</a>
+Node:<a name="Restartable multibyte conversion">Restartable multibyte conversion</a>,
+Next:<a rel=next accesskey=n href="#Non-reentrant Conversion">Non-reentrant Conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Charset Function Overview">Charset Function Overview</a>,
+Up:<a rel=up accesskey=u href="#Character Set Handling">Character Set Handling</a>
 <br>
 
 <h3>Restartable Multibyte Conversion Functions</h3>
 
@@ -13069,9 +12701,9 @@
 <ul>
 <li>The character set assumed for the multibyte encoding is not specified
 as an argument to the functions.  Instead the character set specified by
 the <code>LC_CTYPE</code> category of the current locale is used; see
-<a href="#Locale%20Categories">Locale Categories</a>.
+<a href="#Locale Categories">Locale Categories</a>.
 
 <li>The functions handling more than one character at a time require NUL
 terminated strings as the argument (i.e., converting blocks of text
 does not work unless one can add a NUL byte at an appropriate place). 
@@ -13087,23 +12719,23 @@
 current locale, which determines the translation and therefore also the
 external encoding used.  In such a situation (and many others) the
 functions described here are perfect.  If more freedom while performing
 the conversion is necessary take a look at the <code>iconv</code> functions
-(see <a href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>).
+(see <a href="#Generic Charset Conversion">Generic Charset Conversion</a>).
 
 <ul>
-<li><a accesskey=1 href="#Selecting%20the%20Conversion">Selecting the Conversion</a>:      Selecting the conversion and its properties. 
-<li><a accesskey=2 href="#Keeping%20the%20state">Keeping the state</a>:             Representing the state of the conversion. 
-<li><a accesskey=3 href="#Converting%20a%20Character">Converting a Character</a>:        Converting Single Characters. 
-<li><a accesskey=4 href="#Converting%20Strings">Converting Strings</a>:            Converting Multibyte and Wide Character
+<li><a accesskey=1 href="#Selecting the Conversion">Selecting the Conversion</a>:      Selecting the conversion and its properties. 
+<li><a accesskey=2 href="#Keeping the state">Keeping the state</a>:             Representing the state of the conversion. 
+<li><a accesskey=3 href="#Converting a Character">Converting a Character</a>:        Converting Single Characters. 
+<li><a accesskey=4 href="#Converting Strings">Converting Strings</a>:            Converting Multibyte and Wide Character
                                   Strings. 
-<li><a accesskey=5 href="#Multibyte%20Conversion%20Example">Multibyte Conversion Example</a>:  A Complete Multibyte Conversion Example. 
+<li><a accesskey=5 href="#Multibyte Conversion Example">Multibyte Conversion Example</a>:  A Complete Multibyte Conversion Example. 
 </ul>
 
 <p><hr>
-Node:<a name="Selecting%20the%20Conversion">Selecting the Conversion</a>,
-Next:<a rel=next accesskey=n href="#Keeping%20the%20state">Keeping the state</a>,
-Up:<a rel=up accesskey=u href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>
+Node:<a name="Selecting the Conversion">Selecting the Conversion</a>,
+Next:<a rel=next accesskey=n href="#Keeping the state">Keeping the state</a>,
+Up:<a rel=up accesskey=u href="#Restartable multibyte conversion">Restartable multibyte conversion</a>
 <br>
 
 <h4>Selecting the conversion and its properties</h4>
 
@@ -13120,32 +12752,30 @@
 conversion functions (as shown in the examples below). 
 The ISO&nbsp;C standard defines two macros that provide this information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MB_LEN_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>MB_LEN_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>MB_LEN_MAX</code> specifies the maximum number of bytes in the multibyte
 sequence for a single character in any of the supported locales.  It is
 a compile-time constant and is defined in <code>limits.h</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MB_CUR_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>MB_CUR_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>MB_CUR_MAX</code> expands into a positive integer expression that is the
 maximum number of bytes in a multibyte character in the current locale. 
 The value is never greater than <code>MB_LEN_MAX</code>.  Unlike
@@ -13181,12 +12811,12 @@
 bytes are always available in <var>buf</var>.  Note that it isn't
 a problem if <code>MB_CUR_MAX</code> is not a compile-time constant.
 
 <p><hr>
-Node:<a name="Keeping%20the%20state">Keeping the state</a>,
-Next:<a rel=next accesskey=n href="#Converting%20a%20Character">Converting a Character</a>,
-Previous:<a rel=previous accesskey=p href="#Selecting%20the%20Conversion">Selecting the Conversion</a>,
-Up:<a rel=up accesskey=u href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>
+Node:<a name="Keeping the state">Keeping the state</a>,
+Next:<a rel=next accesskey=n href="#Converting a Character">Converting a Character</a>,
+Previous:<a rel=previous accesskey=p href="#Selecting the Conversion">Selecting the Conversion</a>,
+Up:<a rel=up accesskey=u href="#Restartable multibyte conversion">Restartable multibyte conversion</a>
 <br>
 
 <h4>Representing the state of the conversion</h4>
 
@@ -13198,16 +12828,15 @@
 step we must have a way to pass this information from one call of the
 functions to another.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>mbstate_t</b><i>
-</i></td>
+<td align="left"><code><b>mbstate_t</b><i></i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A variable of type <code>mbstate_t</code> can contain all the information
 about the <dfn>shift state</dfn> needed from one call to a conversion
 function to another.
@@ -13241,16 +12870,15 @@
 escape sequences to set the state to the initial state at certain
 sequence points.  Communication protocols often require this.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mbsinit</b><i> (const mbstate_t *<var>ps</var>)
-</i></td>
+<td align="left"><code>int <b>mbsinit</b><i> (const mbstate_t *<var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mbsinit</code> function determines whether the state object pointed
 to by <var>ps</var> is in the initial state.  If <var>ps</var> is a null pointer or
 the object is in the initial state the return value is nonzero.  Otherwise
@@ -13280,20 +12908,20 @@
 </pre>
 
 <p>The code to emit the escape sequence to get back to the initial state is
 interesting.  The <code>wcsrtombs</code> function can be used to determine the
-necessary output code (see <a href="#Converting%20Strings">Converting Strings</a>).  Please note that on
+necessary output code (see <a href="#Converting Strings">Converting Strings</a>).  Please note that on
 GNU systems it is not necessary to perform this extra action for the
 conversion from multibyte text to wide character text since the wide
 character encoding is not stateful.  But there is nothing mentioned in
 any standard that prohibits making <code>wchar_t</code> using a stateful
 encoding.
 
 <p><hr>
-Node:<a name="Converting%20a%20Character">Converting a Character</a>,
-Next:<a rel=next accesskey=n href="#Converting%20Strings">Converting Strings</a>,
-Previous:<a rel=previous accesskey=p href="#Keeping%20the%20state">Keeping the state</a>,
-Up:<a rel=up accesskey=u href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>
+Node:<a name="Converting a Character">Converting a Character</a>,
+Next:<a rel=next accesskey=n href="#Converting Strings">Converting Strings</a>,
+Previous:<a rel=previous accesskey=p href="#Keeping the state">Keeping the state</a>,
+Up:<a rel=up accesskey=u href="#Restartable multibyte conversion">Restartable multibyte conversion</a>
 <br>
 
 <h4>Converting Single Characters</h4>
 
@@ -13306,16 +12934,15 @@
 stands for itself, and all other characters have at least a first byte
 that is beyond the range 0 to 127.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>btowc</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>wint_t <b>btowc</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>btowc</code> function ("byte to wide character") converts a valid
 single byte character <var>c</var> in the initial shift state into the wide
 character equivalent using the conversion rules from the currently
@@ -13367,16 +12994,15 @@
 
 <p>There also is a function for the conversion in the other direction.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wctob</b><i> (wint_t <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>wctob</b><i> (wint_t <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wctob</code> function ("wide character to byte") takes as the
 parameter a valid wide character.  If the multibyte representation for
 this character in the initial state is exactly one byte long, the return
@@ -13393,16 +13019,15 @@
 functions pose no limit on the length of the multibyte representation
 and they also do not require it to be in the initial state.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>mbrtowc</b><i> (wchar_t *restrict <var>pwc</var>, const char *restrict <var>s</var>, size_t <var>n</var>, mbstate_t *restrict <var>ps</var>)
-</i></td>
+<td align="left"><code>size_t <b>mbrtowc</b><i> (wchar_t *restrict <var>pwc</var>, const char *restrict <var>s</var>, size_t <var>n</var>, mbstate_t *restrict <var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mbrtowc</code> function ("multibyte restartable to wide
 character") converts the next multibyte character in the string pointed
 to by <var>s</var> into a wide character and stores it in the wide character
@@ -13492,16 +13117,15 @@
 character string directly from the multibyte string.  There is, however, a
 function that does part of the work.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>mbrlen</b><i> (const char *restrict <var>s</var>, size_t <var>n</var>, mbstate_t *<var>ps</var>)
-</i></td>
+<td align="left"><code>size_t <b>mbrlen</b><i> (const char *restrict <var>s</var>, size_t <var>n</var>, mbstate_t *<var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mbrlen</code> function ("multibyte restartable length") computes
 the number of at most <var>n</var> bytes starting at <var>s</var>, which form the
 next valid and complete multibyte character.
@@ -13579,16 +13203,15 @@
 about the consequences of using the easier but imprecise method before
 doing the work twice.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcrtomb</b><i> (char *restrict <var>s</var>, wchar_t <var>wc</var>, mbstate_t *restrict <var>ps</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcrtomb</b><i> (char *restrict <var>s</var>, wchar_t <var>wc</var>, mbstate_t *restrict <var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcrtomb</code> function ("wide character restartable to
 multibyte") converts a single wide character into a multibyte string
 corresponding to that wide character.
@@ -13716,12 +13339,12 @@
 <p>There are certainly many more and even better solutions to this problem. 
 This example is only provided for educational purposes.
 
 <p><hr>
-Node:<a name="Converting%20Strings">Converting Strings</a>,
-Next:<a rel=next accesskey=n href="#Multibyte%20Conversion%20Example">Multibyte Conversion Example</a>,
-Previous:<a rel=previous accesskey=p href="#Converting%20a%20Character">Converting a Character</a>,
-Up:<a rel=up accesskey=u href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>
+Node:<a name="Converting Strings">Converting Strings</a>,
+Next:<a rel=next accesskey=n href="#Multibyte Conversion Example">Multibyte Conversion Example</a>,
+Previous:<a rel=previous accesskey=p href="#Converting a Character">Converting a Character</a>,
+Up:<a rel=up accesskey=u href="#Restartable multibyte conversion">Restartable multibyte conversion</a>
 <br>
 
 <h4>Converting Multibyte and Wide Character Strings</h4>
 
@@ -13732,16 +13355,15 @@
 functions is quite limited; therefore, the GNU C library contains a few
 extensions that can help in some important situations.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>mbsrtowcs</b><i> (wchar_t *restrict <var>dst</var>, const char **restrict <var>src</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)
-</i></td>
+<td align="left"><code>size_t <b>mbsrtowcs</b><i> (wchar_t *restrict <var>dst</var>, const char **restrict <var>src</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mbsrtowcs</code> function ("multibyte string restartable to wide
 character string") converts an NUL-terminated multibyte character
 string at <code>*<var>src</var></code> into an equivalent wide character string,
@@ -13808,25 +13430,24 @@
 this is not a strict guarantee.  Therefore, simply NUL-terminating a
 piece of a running text is not always an adequate solution and,
 therefore, should never be used in generally used code.
 
-<p>The generic conversion interface (see <a href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>)
+<p>The generic conversion interface (see <a href="#Generic Charset Conversion">Generic Charset Conversion</a>)
 does not have this limitation (it simply works on buffers, not
 strings), and the GNU C library contains a set of functions that take
 additional parameters specifying the maximal number of bytes that are
 consumed from the input string.  This way the problem of
 <code>mbsrtowcs</code>'s example above could be solved by determining the line
 length and passing this length to the function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcsrtombs</b><i> (char *restrict <var>dst</var>, const wchar_t **restrict <var>src</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcsrtombs</b><i> (char *restrict <var>dst</var>, const wchar_t **restrict <var>src</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcsrtombs</code> function ("wide character string restartable to
 multibyte string") converts the NUL-terminated wide character string at
 <code>*<var>src</var></code> into an equivalent multibyte character string and
@@ -13869,16 +13490,15 @@
 place or control the consumed input indirectly via the available output
 array size (the <var>len</var> parameter).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>mbsnrtowcs</b><i> (wchar_t *restrict <var>dst</var>, const char **restrict <var>src</var>, size_t <var>nmc</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)
-</i></td>
+<td align="left"><code>size_t <b>mbsnrtowcs</b><i> (wchar_t *restrict <var>dst</var>, const char **restrict <var>src</var>, size_t <var>nmc</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mbsnrtowcs</code> function is very similar to the <code>mbsrtowcs</code>
 function.  All the parameters are the same except for <var>nmc</var>, which is
 new.  The return value is the same as for <code>mbsrtowcs</code>.
@@ -13928,16 +13548,15 @@
 right from the beginning and we use <var>state</var> only for the conversion
 of the given buffer, there is no problem with altering the state.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcsnrtombs</b><i> (char *restrict <var>dst</var>, const wchar_t **restrict <var>src</var>, size_t <var>nwc</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcsnrtombs</b><i> (char *restrict <var>dst</var>, const wchar_t **restrict <var>src</var>, size_t <var>nwc</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcsnrtombs</code> function implements the conversion from wide
 character strings to multibyte character strings.  It is similar to
 <code>wcsrtombs</code> but, just like <code>mbsnrtowcs</code>, it takes an extra
@@ -13954,11 +13573,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Multibyte%20Conversion%20Example">Multibyte Conversion Example</a>,
-Previous:<a rel=previous accesskey=p href="#Converting%20Strings">Converting Strings</a>,
-Up:<a rel=up accesskey=u href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>
+Node:<a name="Multibyte Conversion Example">Multibyte Conversion Example</a>,
+Previous:<a rel=previous accesskey=p href="#Converting Strings">Converting Strings</a>,
+Up:<a rel=up accesskey=u href="#Restartable multibyte conversion">Restartable multibyte conversion</a>
 <br>
 
 <h4>A Complete Multibyte Conversion Example</h4>
 
@@ -14047,12 +13666,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Non-reentrant%20Conversion">Non-reentrant Conversion</a>,
-Next:<a rel=next accesskey=n href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Restartable%20multibyte%20conversion">Restartable multibyte conversion</a>,
-Up:<a rel=up accesskey=u href="#Character%20Set%20Handling">Character Set Handling</a>
+Node:<a name="Non-reentrant Conversion">Non-reentrant Conversion</a>,
+Next:<a rel=next accesskey=n href="#Generic Charset Conversion">Generic Charset Conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Restartable multibyte conversion">Restartable multibyte conversion</a>,
+Up:<a rel=up accesskey=u href="#Character Set Handling">Character Set Handling</a>
 <br>
 
 <h3>Non-reentrant Conversion Function</h3>
 
@@ -14078,31 +13697,30 @@
 described in the previous section be used in place of non-reentrant
 conversion functions.</strong>
 
 <ul>
-<li><a accesskey=1 href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>:   Non-reentrant Conversion of Single
+<li><a accesskey=1 href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>:   Non-reentrant Conversion of Single
                                          Characters. 
-<li><a accesskey=2 href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>:      Non-reentrant Conversion of Strings. 
-<li><a accesskey=3 href="#Shift%20State">Shift State</a>:                          States in Non-reentrant Functions. 
+<li><a accesskey=2 href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>:      Non-reentrant Conversion of Strings. 
+<li><a accesskey=3 href="#Shift State">Shift State</a>:                          States in Non-reentrant Functions. 
 </ul>
 
 <p><hr>
-Node:<a name="Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>,
-Next:<a rel=next accesskey=n href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>,
-Up:<a rel=up accesskey=u href="#Non-reentrant%20Conversion">Non-reentrant Conversion</a>
+Node:<a name="Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>,
+Next:<a rel=next accesskey=n href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>,
+Up:<a rel=up accesskey=u href="#Non-reentrant Conversion">Non-reentrant Conversion</a>
 <br>
 
 <h4>Non-reentrant Conversion of Single Characters</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mbtowc</b><i> (wchar_t *restrict <var>result</var>, const char *restrict <var>string</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>mbtowc</b><i> (wchar_t *restrict <var>result</var>, const char *restrict <var>string</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mbtowc</code> ("multibyte to wide character") function when called
 with non-null <var>string</var> converts the first multibyte character
 beginning at <var>string</var> to its corresponding wide character code.  It
@@ -14130,21 +13748,20 @@
 <code>mbtowc</code> maintains and updates a shift state as it scans.  If you
 call <code>mbtowc</code> with a null pointer for <var>string</var>, that
 initializes the shift state to its standard initial value.  It also
 returns nonzero if the multibyte character code in use actually has a
-shift state.  See <a href="#Shift%20State">Shift State</a>. 
+shift state.  See <a href="#Shift State">Shift State</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wctomb</b><i> (char *<var>string</var>, wchar_t <var>wchar</var>)
-</i></td>
+<td align="left"><code>int <b>wctomb</b><i> (char *<var>string</var>, wchar_t <var>wchar</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wctomb</code> ("wide character to multibyte") function converts
 the wide character code <var>wchar</var> to its corresponding multibyte
 character sequence, and stores the result in bytes starting at
@@ -14168,9 +13785,9 @@
 <code>wctomb</code> maintains and updates a shift state as it scans.  If you
 call <code>wctomb</code> with a null pointer for <var>string</var>, that
 initializes the shift state to its standard initial value.  It also
 returns nonzero if the multibyte character code in use actually has a
-shift state.  See <a href="#Shift%20State">Shift State</a>.
+shift state.  See <a href="#Shift State">Shift State</a>.
 
 <p>Calling this function with a <var>wchar</var> argument of zero when
 <var>string</var> is not null has the side-effect of reinitializing the
 stored shift state <em>as well as</em> storing the multibyte character
@@ -14182,16 +13799,15 @@
 computes the length of a multibyte character.  It can be defined in
 terms of <code>mbtowc</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mblen</b><i> (const char *<var>string</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>mblen</b><i> (const char *<var>string</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mblen</code> function with a non-null <var>string</var> argument returns
 the number of bytes that make up the multibyte character beginning at
 <var>string</var>, never examining more than <var>size</var> bytes.  (The idea is
@@ -14211,37 +13827,36 @@
 maintains and updates a shift state as it scans.  If you call
 <code>mblen</code> with a null pointer for <var>string</var>, that initializes the
 shift state to its standard initial value.  It also returns a nonzero
 value if the multibyte character code in use actually has a shift state. 
-See <a href="#Shift%20State">Shift State</a>.
+See <a href="#Shift State">Shift State</a>.
 
 <p>The function <code>mblen</code> is declared in <code>stdlib.h</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>,
-Next:<a rel=next accesskey=n href="#Shift%20State">Shift State</a>,
-Previous:<a rel=previous accesskey=p href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>,
-Up:<a rel=up accesskey=u href="#Non-reentrant%20Conversion">Non-reentrant Conversion</a>
+Node:<a name="Non-reentrant String Conversion">Non-reentrant String Conversion</a>,
+Next:<a rel=next accesskey=n href="#Shift State">Shift State</a>,
+Previous:<a rel=previous accesskey=p href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>,
+Up:<a rel=up accesskey=u href="#Non-reentrant Conversion">Non-reentrant Conversion</a>
 <br>
 
 <h4>Non-reentrant Conversion of Strings</h4>
 
 <p>For convenience the ISO&nbsp;C90 standard also defines functions to
 convert entire strings instead of single characters.  These functions
 suffer from the same problems as their reentrant counterparts from
-Amendment&nbsp;1 to ISO&nbsp;C90; see <a href="#Converting%20Strings">Converting Strings</a>.
+Amendment&nbsp;1 to ISO&nbsp;C90; see <a href="#Converting Strings">Converting Strings</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>mbstowcs</b><i> (wchar_t *<var>wstring</var>, const char *<var>string</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>size_t <b>mbstowcs</b><i> (wchar_t *<var>wstring</var>, const char *<var>string</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mbstowcs</code> ("multibyte string to wide character string")
 function converts the null-terminated string of multibyte characters
 <var>string</var> to an array of wide character codes, storing not more than
@@ -14279,16 +13894,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcstombs</b><i> (char *<var>string</var>, const wchar_t *<var>wstring</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcstombs</b><i> (char *<var>string</var>, const wchar_t *<var>wstring</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstombs</code> ("wide character string to multibyte string")
 function converts the null-terminated wide character array <var>wstring</var>
 into a string containing multibyte characters, storing not more than
@@ -14308,11 +13922,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Shift%20State">Shift State</a>,
-Previous:<a rel=previous accesskey=p href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>,
-Up:<a rel=up accesskey=u href="#Non-reentrant%20Conversion">Non-reentrant Conversion</a>
+Node:<a name="Shift State">Shift State</a>,
+Previous:<a rel=previous accesskey=p href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>,
+Up:<a rel=up accesskey=u href="#Non-reentrant Conversion">Non-reentrant Conversion</a>
 <br>
 
 <h4>States in Non-reentrant Functions</h4>
 
@@ -14381,11 +13995,11 @@
 no other library functions call these functions, so you don't have to
 worry that the shift state will be changed mysteriously.
 
 <p><hr>
-Node:<a name="Generic%20Charset%20Conversion">Generic Charset Conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Non-reentrant%20Conversion">Non-reentrant Conversion</a>,
-Up:<a rel=up accesskey=u href="#Character%20Set%20Handling">Character Set Handling</a>
+Node:<a name="Generic Charset Conversion">Generic Charset Conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Non-reentrant Conversion">Non-reentrant Conversion</a>,
+Up:<a rel=up accesskey=u href="#Character Set Handling">Character Set Handling</a>
 <br>
 
 <h3>Generic Charset Conversion</h3>
 
@@ -14406,9 +14020,9 @@
 <code>setlocale</code>.
 
 <p>Changing the <code>LC_TYPE</code> locale introduces major problems for the rest
 of the programs since several more functions (e.g., the character
-classification functions, see <a href="#Classification%20of%20Characters">Classification of Characters</a>) use the
+classification functions, see <a href="#Classification of Characters">Classification of Characters</a>) use the
 <code>LC_CTYPE</code> category.
 
 </p><li>Parallel conversions to and from different character sets are not
 possible since the <code>LC_CTYPE</code> selection is global and shared by all
@@ -14441,20 +14055,20 @@
 applications.  Finally, the implementation is described in so far as might
 interest the advanced user who wants to extend conversion capabilities.
 
 <ul>
-<li><a accesskey=1 href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>:     Generic Character Set Conversion Interface. 
-<li><a accesskey=2 href="#iconv%20Examples">iconv Examples</a>:                   A complete <code>iconv</code> example. 
-<li><a accesskey=3 href="#Other%20iconv%20Implementations">Other iconv Implementations</a>:      Some Details about other <code>iconv</code>
+<li><a accesskey=1 href="#Generic Conversion Interface">Generic Conversion Interface</a>:     Generic Character Set Conversion Interface. 
+<li><a accesskey=2 href="#iconv Examples">iconv Examples</a>:                   A complete <code>iconv</code> example. 
+<li><a accesskey=3 href="#Other iconv Implementations">Other iconv Implementations</a>:      Some Details about other <code>iconv</code>
                                      Implementations. 
-<li><a accesskey=4 href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>:       The <code>iconv</code> Implementation in the GNU C
+<li><a accesskey=4 href="#glibc iconv Implementation">glibc iconv Implementation</a>:       The <code>iconv</code> Implementation in the GNU C
                                      library. 
 </ul>
 
 <p><hr>
-Node:<a name="Generic%20Conversion%20Interface">Generic Conversion Interface</a>,
-Next:<a rel=next accesskey=n href="#iconv%20Examples">iconv Examples</a>,
-Up:<a rel=up accesskey=u href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>
+Node:<a name="Generic Conversion Interface">Generic Conversion Interface</a>,
+Next:<a rel=next accesskey=n href="#iconv Examples">iconv Examples</a>,
+Up:<a rel=up accesskey=u href="#Generic Charset Conversion">Generic Charset Conversion</a>
 <br>
 
 <h4>Generic Character Set Conversion Interface</h4>
 
@@ -14467,16 +14081,15 @@
 introduced here work using handles and the <code>iconv.h</code> header
 defines a special type for the handles used.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>iconv_t</b><i>
-</i></td>
+<td align="left"><code><b>iconv_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is an abstract type defined in <code>iconv.h</code>.  The user
 must not assume anything about the definition of this type; it must be
 completely opaque.
@@ -14489,16 +14102,15 @@
 
 <p>The first step is the function to create a handle.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">iconv_t <b>iconv_open</b><i> (const char *<var>tocode</var>, const char *<var>fromcode</var>)
-</i></td>
+<td align="left"><code>iconv_t <b>iconv_open</b><i> (const char *<var>tocode</var>, const char *<var>fromcode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>iconv_open</code> function has to be used before starting a
 conversion.  The two parameters this function takes determine the
 source and destination character set for the conversion, and if the
@@ -14533,9 +14145,9 @@
 significant extension to other implementations.  To ease the extension
 of the set of available conversions, the implementation allows storing
 the necessary files with data and code in an arbitrary number of
 directories.  How this extension must be written will be explained below
-(see <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>).  Here it is only important to say
+(see <a href="#glibc iconv Implementation">glibc iconv Implementation</a>).  Here it is only important to say
 that all directories mentioned in the <code>GCONV_PATH</code> environment
 variable are considered only if they contain a file <code>gconv-modules</code>. 
 These directories need not necessarily be created by the system
 administrator.  In fact, this extension is introduced to help users
@@ -14560,16 +14172,15 @@
 free all the resources once all conversions are carried out and the
 conversion is not needed anymore.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>iconv_close</b><i> (iconv_t <var>cd</var>)
-</i></td>
+<td align="left"><code>int <b>iconv_close</b><i> (iconv_t <var>cd</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>iconv_close</code> function frees all resources associated with the
 handle <var>cd</var>, which must have been returned by a successful call to
 the <code>iconv_open</code> function.
@@ -14593,16 +14204,15 @@
 buffer to another.  Conversion from a file to a buffer, vice versa, or
 even file to file can be implemented on top of it.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>iconv</b><i> (iconv_t <var>cd</var>, char **<var>inbuf</var>, size_t *<var>inbytesleft</var>, char **<var>outbuf</var>, size_t *<var>outbytesleft</var>)
-</i></td>
+<td align="left"><code>size_t <b>iconv</b><i> (iconv_t <var>cd</var>, char **<var>inbuf</var>, size_t *<var>inbytesleft</var>, char **<var>outbuf</var>, size_t *<var>outbytesleft</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>iconv</code> function converts the text in the input buffer
 according to the rules associated with the descriptor <var>cd</var> and
 stores the result in the output buffer.  It is possible to call the
@@ -14697,12 +14307,12 @@
 available conversions.  We will see how this negatively impacts other
 implementations, as demonstrated below.
 
 <p><hr>
-Node:<a name="iconv%20Examples">iconv Examples</a>,
-Next:<a rel=next accesskey=n href="#Other%20iconv%20Implementations">Other iconv Implementations</a>,
-Previous:<a rel=previous accesskey=p href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>,
-Up:<a rel=up accesskey=u href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>
+Node:<a name="iconv Examples">iconv Examples</a>,
+Next:<a rel=next accesskey=n href="#Other iconv Implementations">Other iconv Implementations</a>,
+Previous:<a rel=previous accesskey=p href="#Generic Conversion Interface">Generic Conversion Interface</a>,
+Up:<a rel=up accesskey=u href="#Generic Charset Conversion">Generic Charset Conversion</a>
 <br>
 
 <h4>A complete <code>iconv</code> example</h4>
 
@@ -14832,12 +14442,12 @@
 set one uses and, therefore, treats text as a sequence of bytes, it might
 become tricky.
 
 <p><hr>
-Node:<a name="Other%20iconv%20Implementations">Other iconv Implementations</a>,
-Next:<a rel=next accesskey=n href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>,
-Previous:<a rel=previous accesskey=p href="#iconv%20Examples">iconv Examples</a>,
-Up:<a rel=up accesskey=u href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>
+Node:<a name="Other iconv Implementations">Other iconv Implementations</a>,
+Next:<a rel=next accesskey=n href="#glibc iconv Implementation">glibc iconv Implementation</a>,
+Previous:<a rel=previous accesskey=p href="#iconv Examples">iconv Examples</a>,
+Up:<a rel=up accesskey=u href="#Generic Charset Conversion">Generic Charset Conversion</a>
 <br>
 
 <h4>Some Details about other <code>iconv</code> Implementations</h4>
 
@@ -14949,11 +14559,11 @@
 such conversion, one could make sure this also is true for indirect
 routes.
 
 <p><hr>
-Node:<a name="glibc%20iconv%20Implementation">glibc iconv Implementation</a>,
-Previous:<a rel=previous accesskey=p href="#Other%20iconv%20Implementations">Other iconv Implementations</a>,
-Up:<a rel=up accesskey=u href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>
+Node:<a name="glibc iconv Implementation">glibc iconv Implementation</a>,
+Previous:<a rel=previous accesskey=p href="#Other iconv Implementations">Other iconv Implementations</a>,
+Up:<a rel=up accesskey=u href="#Generic Charset Conversion">Generic Charset Conversion</a>
 <br>
 
 <h4>The <code>iconv</code> Implementation in the GNU C library</h4>
 
@@ -15153,16 +14763,15 @@
 conversion and the second describes the state etc.  There are really two
 type definitions like this in <code>gconv.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct __gconv_step</b><i>
-</i></td>
+<td align="left"><code><b>struct __gconv_step</b><i></i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data structure describes one conversion a module can perform.  For
 each function in a loaded module with conversion functions there is
 exactly one object of this type.  This object is shared by all users of
@@ -15229,16 +14838,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct __gconv_step_data</b><i>
-</i></td>
+<td align="left"><code><b>struct __gconv_step_data</b><i></i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data structure that contains the information specific to
 each use of the conversion functions.
 
@@ -15305,9 +14913,9 @@
 <p>This element must never be modified.
 
 <br><dt><code>mbstate_t *__statep</code>
 <dd>The <code>__statep</code> element points to an object of type <code>mbstate_t</code>
-(see <a href="#Keeping%20the%20state">Keeping the state</a>).  The conversion of a stateful character
+(see <a href="#Keeping the state">Keeping the state</a>).  The conversion of a stateful character
 set must use the object pointed to by <code>__statep</code> to store
 information about the conversion state.  The <code>__statep</code> element
 itself must never be modified.
 
@@ -15368,16 +14976,15 @@
 <p>There are three data types defined for the three module interface
 functions and these define the interface.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>(*__gconv_init_fct)</b><i> (struct __gconv_step *)
-</i></td>
+<td align="left"><code>int <b>(*__gconv_init_fct)</b><i> (struct __gconv_step *)</i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This specifies the interface of the initialization function of the
 module.  It is called exactly once for each conversion the module
 implements.
@@ -15532,16 +15139,15 @@
 easier.  It often has nothing at all to do; in which case it can be left
 out completely.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>(*__gconv_end_fct)</b><i> (struct gconv_step *)
-</i></td>
+<td align="left"><code>void <b>(*__gconv_end_fct)</b><i> (struct gconv_step *)</i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The task of this function is to free all resources allocated in the
 initialization function.  Therefore only the <code>__data</code> element of
 the object pointed to by the argument is of interest.  Continuing the
@@ -15562,16 +15168,15 @@
 of interest here, we will only describe a possible skeleton for the
 conversion function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>(*__gconv_fct)</b><i> (struct __gconv_step *, struct __gconv_step_data *, const char **, const char *, size_t *, int)
-</i></td>
+<td align="left"><code>int <b>(*__gconv_fct)</b><i> (struct __gconv_step *, struct __gconv_step_data *, const char **, const char *, size_t *, int)</i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The conversion function can be called for two basic reason: to convert
 text or to reset the state.  From the description of the <code>iconv</code>
 function it can be seen why the flushing mode is necessary.  What mode
@@ -15816,10 +15421,10 @@
 modules.
 
 <p><hr>
 Node:<a name="Locales">Locales</a>,
-Next:<a rel=next accesskey=n href="#Message%20Translation">Message Translation</a>,
-Previous:<a rel=previous accesskey=p href="#Character%20Set%20Handling">Character Set Handling</a>,
+Next:<a rel=next accesskey=n href="#Message Translation">Message Translation</a>,
+Previous:<a rel=previous accesskey=p href="#Character Set Handling">Character Set Handling</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Locales and Internationalization</h2>
@@ -15840,24 +15445,24 @@
 Provided the programs are written to obey the choice of locale, they
 will follow the conventions preferred by the user.
 
 <ul>
-<li><a accesskey=1 href="#Effects%20of%20Locale">Effects of Locale</a>:            Actions affected by the choice of
+<li><a accesskey=1 href="#Effects of Locale">Effects of Locale</a>:            Actions affected by the choice of
                                  locale. 
-<li><a accesskey=2 href="#Choosing%20Locale">Choosing Locale</a>:              How the user specifies a locale. 
-<li><a accesskey=3 href="#Locale%20Categories">Locale Categories</a>:            Different purposes for which you can
+<li><a accesskey=2 href="#Choosing Locale">Choosing Locale</a>:              How the user specifies a locale. 
+<li><a accesskey=3 href="#Locale Categories">Locale Categories</a>:            Different purposes for which you can
                                  select a locale. 
-<li><a accesskey=4 href="#Setting%20the%20Locale">Setting the Locale</a>:           How a program specifies the locale
+<li><a accesskey=4 href="#Setting the Locale">Setting the Locale</a>:           How a program specifies the locale
                                  with library functions. 
-<li><a accesskey=5 href="#Standard%20Locales">Standard Locales</a>:             Locale names available on all systems. 
-<li><a accesskey=6 href="#Locale%20Information">Locale Information</a>:           How to access the information for the locale. 
-<li><a accesskey=7 href="#Formatting%20Numbers">Formatting Numbers</a>:           A dedicated function to format numbers. 
-<li><a accesskey=8 href="#Yes-or-No%20Questions">Yes-or-No Questions</a>:          Check a Response against the locale. 
+<li><a accesskey=5 href="#Standard Locales">Standard Locales</a>:             Locale names available on all systems. 
+<li><a accesskey=6 href="#Locale Information">Locale Information</a>:           How to access the information for the locale. 
+<li><a accesskey=7 href="#Formatting Numbers">Formatting Numbers</a>:           A dedicated function to format numbers. 
+<li><a accesskey=8 href="#Yes-or-No Questions">Yes-or-No Questions</a>:          Check a Response against the locale. 
 </ul>
 
 <p><hr>
-Node:<a name="Effects%20of%20Locale">Effects of Locale</a>,
-Next:<a rel=next accesskey=n href="#Choosing%20Locale">Choosing Locale</a>,
+Node:<a name="Effects of Locale">Effects of Locale</a>,
+Next:<a rel=next accesskey=n href="#Choosing Locale">Choosing Locale</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>What Effects a Locale Has</h3>
@@ -15866,26 +15471,26 @@
 following:
 
 <ul>
 <li>What multibyte character sequences are valid, and how they are
-interpreted (see <a href="#Character%20Set%20Handling">Character Set Handling</a>).
+interpreted (see <a href="#Character Set Handling">Character Set Handling</a>).
 
 <li>Classification of which characters in the local character set are
 considered alphabetic, and upper- and lower-case conversion conventions
-(see <a href="#Character%20Handling">Character Handling</a>).
+(see <a href="#Character Handling">Character Handling</a>).
 
 <li>The collating sequence for the local language and character set
-(see <a href="#Collation%20Functions">Collation Functions</a>).
+(see <a href="#Collation Functions">Collation Functions</a>).
 
-<li>Formatting of numbers and currency amounts (see <a href="#General%20Numeric">General Numeric</a>).
+<li>Formatting of numbers and currency amounts (see <a href="#General Numeric">General Numeric</a>).
 
-<li>Formatting of dates and times (see <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>).
+<li>Formatting of dates and times (see <a href="#Formatting Calendar Time">Formatting Calendar Time</a>).
 
 <li>What language to use for output, including error messages
-(see <a href="#Message%20Translation">Message Translation</a>).
+(see <a href="#Message Translation">Message Translation</a>).
 
 <li>What language to use for user answers to yes-or-no questions
-(see <a href="#Yes-or-No%20Questions">Yes-or-No Questions</a>).
+(see <a href="#Yes-or-No Questions">Yes-or-No Questions</a>).
 
 <li>What language to use for more complex user input. 
 (The C library doesn't yet help you implement this.) 
 </ul>
@@ -15906,11 +15511,11 @@
 locale.  The effects of the current locale on specific library functions
 are discussed in more detail in the descriptions of those functions.
 
 <p><hr>
-Node:<a name="Choosing%20Locale">Choosing Locale</a>,
-Next:<a rel=next accesskey=n href="#Locale%20Categories">Locale Categories</a>,
-Previous:<a rel=previous accesskey=p href="#Effects%20of%20Locale">Effects of Locale</a>,
+Node:<a name="Choosing Locale">Choosing Locale</a>,
+Next:<a rel=next accesskey=n href="#Locale Categories">Locale Categories</a>,
+Previous:<a rel=previous accesskey=p href="#Effects of Locale">Effects of Locale</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>Choosing a Locale</h3>
@@ -15940,11 +15545,11 @@
 which locales apply.  However, the user can choose to use each locale
 for a particular subset of those purposes.
 
 <p><hr>
-Node:<a name="Locale%20Categories">Locale Categories</a>,
-Next:<a rel=next accesskey=n href="#Setting%20the%20Locale">Setting the Locale</a>,
-Previous:<a rel=previous accesskey=p href="#Choosing%20Locale">Choosing Locale</a>,
+Node:<a name="Locale Categories">Locale Categories</a>,
+Next:<a rel=next accesskey=n href="#Setting the Locale">Setting the Locale</a>,
+Previous:<a rel=previous accesskey=p href="#Choosing Locale">Choosing Locale</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>Categories of Activities that Locales Affect</h3>
@@ -15957,30 +15562,30 @@
 
 <dl>
 <dt><code>LC_COLLATE</code>
 <dd>This category applies to collation of strings (functions <code>strcoll</code>
-and <code>strxfrm</code>); see <a href="#Collation%20Functions">Collation Functions</a>.
+and <code>strxfrm</code>); see <a href="#Collation Functions">Collation Functions</a>.
 
 <br><dt><code>LC_CTYPE</code>
 <dd>This category applies to classification and conversion of characters,
 and to multibyte and wide characters;
-see <a href="#Character%20Handling">Character Handling</a>, and <a href="#Character%20Set%20Handling">Character Set Handling</a>.
+see <a href="#Character Handling">Character Handling</a>, and <a href="#Character Set Handling">Character Set Handling</a>.
 
 <br><dt><code>LC_MONETARY</code>
-<dd>This category applies to formatting monetary values; see <a href="#General%20Numeric">General Numeric</a>.
+<dd>This category applies to formatting monetary values; see <a href="#General Numeric">General Numeric</a>.
 
 <br><dt><code>LC_NUMERIC</code>
 <dd>This category applies to formatting numeric values that are not
-monetary; see <a href="#General%20Numeric">General Numeric</a>.
+monetary; see <a href="#General Numeric">General Numeric</a>.
 
 <br><dt><code>LC_TIME</code>
 <dd>This category applies to formatting date and time values; see
-<a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>.
+<a href="#Formatting Calendar Time">Formatting Calendar Time</a>.
 
 <br><dt><code>LC_MESSAGES</code>
 <dd>This category applies to selecting the language used in the user
-interface for message translation (see <a href="#The%20Uniforum%20approach">The Uniforum approach</a>;
-see <a href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>)  and contains regular expressions
+interface for message translation (see <a href="#The Uniforum approach">The Uniforum approach</a>;
+see <a href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>)  and contains regular expressions
 for affirmative and negative responses.
 
 <br><dt><code>LC_ALL</code>
 <dd>This is not an environment variable; it is only a macro that you can use
@@ -16000,14 +15605,14 @@
 whose messages are output in English by default.  It should be possible
 to specify that the first choice of language is Swedish, the second
 German, and if this also fails to use English.  This is
 possible with the variable <code>LANGUAGE</code>.  For further description of
-this GNU extension see <a href="#Using%20gettextized%20software">Using gettextized software</a>.
+this GNU extension see <a href="#Using gettextized software">Using gettextized software</a>.
 
 <p><hr>
-Node:<a name="Setting%20the%20Locale">Setting the Locale</a>,
-Next:<a rel=next accesskey=n href="#Standard%20Locales">Standard Locales</a>,
-Previous:<a rel=previous accesskey=p href="#Locale%20Categories">Locale Categories</a>,
+Node:<a name="Setting the Locale">Setting the Locale</a>,
+Next:<a rel=next accesskey=n href="#Standard Locales">Standard Locales</a>,
+Previous:<a rel=previous accesskey=p href="#Locale Categories">Locale Categories</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>How Programs Set the Locale</h3>
@@ -16030,16 +15635,15 @@
 
 <p>The symbols in this section are defined in the header file <code>locale.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>setlocale</b><i> (int <var>category</var>, const char *<var>locale</var>)
-</i></td>
+<td align="left"><code>char * <b>setlocale</b><i> (int <var>category</var>, const char *<var>locale</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>setlocale</code> sets the current locale for category
 <var>category</var> to <var>locale</var>.  A list of all the locales the system
 provides can be created by running
@@ -16048,17 +15652,17 @@
 </pre>
 
 <p>If <var>category</var> is <code>LC_ALL</code>, this specifies the locale for all
 purposes.  The other possible values of <var>category</var> specify an
-single purpose (see <a href="#Locale%20Categories">Locale Categories</a>).
+single purpose (see <a href="#Locale Categories">Locale Categories</a>).
 
 <p>You can also use this function to find out the current locale by passing
 a null pointer as the <var>locale</var> argument.  In this case,
 <code>setlocale</code> returns a string that is the name of the locale
 currently selected for category <var>category</var>.
 
 <p>The string returned by <code>setlocale</code> can be overwritten by subsequent
-calls, so you should make a copy of the string (see <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>) if you want to save it past any further calls to
+calls, so you should make a copy of the string (see <a href="#Copying and Concatenation">Copying and Concatenation</a>) if you want to save it past any further calls to
 <code>setlocale</code>.  (The standard library is guaranteed never to call
 <code>setlocale</code> itself.)
 
 <p>You should not modify the string returned by <code>setlocale</code>.  It might
@@ -16131,11 +15735,11 @@
 portability, assume that any symbol beginning with <code>LC_</code> might be
 defined in <code>locale.h</code>.
 
 <p><hr>
-Node:<a name="Standard%20Locales">Standard Locales</a>,
-Next:<a rel=next accesskey=n href="#Locale%20Information">Locale Information</a>,
-Previous:<a rel=previous accesskey=p href="#Setting%20the%20Locale">Setting the Locale</a>,
+Node:<a name="Standard Locales">Standard Locales</a>,
+Next:<a rel=next accesskey=n href="#Locale Information">Locale Information</a>,
+Previous:<a rel=previous accesskey=p href="#Setting the Locale">Setting the Locale</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>Standard Locales</h3>
@@ -16154,9 +15758,9 @@
 standard C locale.
 
 <br><dt><code>""</code>
 <dd>The empty name says to select a locale based on environment variables. 
-See <a href="#Locale%20Categories">Locale Categories</a>. 
+See <a href="#Locale Categories">Locale Categories</a>. 
 </dl>
 
 <p>Defining and installing named locales is normally a responsibility of
 the system administrator at your site (or the person who installed the
@@ -16170,11 +15774,11 @@
 locale explicitly by name.  Remember, different machines might have
 different sets of locales installed.
 
 <p><hr>
-Node:<a name="Locale%20Information">Locale Information</a>,
-Next:<a rel=next accesskey=n href="#Formatting%20Numbers">Formatting Numbers</a>,
-Previous:<a rel=previous accesskey=p href="#Standard%20Locales">Standard Locales</a>,
+Node:<a name="Locale Information">Locale Information</a>,
+Next:<a rel=next accesskey=n href="#Formatting Numbers">Formatting Numbers</a>,
+Previous:<a rel=previous accesskey=p href="#Standard Locales">Standard Locales</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>Accessing Locale Information</h3>
@@ -16185,9 +15789,9 @@
 what information is provided by the currently selected locale.  This is
 how the locale model is meant to work normally.
 
 <p>As an example take the <code>strftime</code> function, which is meant to nicely
-format date and time information (see <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>). 
+format date and time information (see <a href="#Formatting Calendar Time">Formatting Calendar Time</a>). 
 Part of the standard information contained in the <code>LC_TIME</code>
 category is the names of the months.  Instead of requiring the
 programmer to take care of providing the translations the
 <code>strftime</code> function does this all by itself.  <code>%A</code>
@@ -16205,16 +15809,16 @@
 interface.  The second is part of the Unix interface and is portable in
 as far as the system follows the Unix standards.
 
 <ul>
-<li><a accesskey=1 href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>:    ISO C's <code>localeconv</code>. 
-<li><a accesskey=2 href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>:       X/Open's <code>nl_langinfo</code>. 
+<li><a accesskey=1 href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>:    ISO C's <code>localeconv</code>. 
+<li><a accesskey=2 href="#The Elegant and Fast Way">The Elegant and Fast Way</a>:       X/Open's <code>nl_langinfo</code>. 
 </ul>
 
 <p><hr>
-Node:<a name="The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>,
-Next:<a rel=next accesskey=n href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>,
-Up:<a rel=up accesskey=u href="#Locale%20Information">Locale Information</a>
+Node:<a name="The Lame Way to Locale Data">The Lame Way to Locale Data</a>,
+Next:<a rel=next accesskey=n href="#The Elegant and Fast Way">The Elegant and Fast Way</a>,
+Up:<a rel=up accesskey=u href="#Locale Information">Locale Information</a>
 <br>
 
 <h4><code>localeconv</code>: It is portable but <small>...</small></h4>
 
@@ -16227,16 +15831,15 @@
 portable.  The function <code>strfmon</code> formats monetary amounts
 according to the selected locale using this information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct lconv * <b>localeconv</b><i> (void)
-</i></td>
+<td align="left"><code>struct lconv * <b>localeconv</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>localeconv</code> function returns a pointer to a structure whose
 components contain information about how numeric and monetary values
 should be formatted in the current locale.
@@ -16248,16 +15851,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct lconv</b><i>
-</i></td>
+<td align="left"><code><b>struct lconv</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>localeconv</code>'s return value is of this data type.  Its elements are
 described in the following subsections. 
 </td></tr>
@@ -16267,20 +15869,20 @@
 and the value is <code>CHAR_MAX</code>, it means that the current locale has
 no value for that parameter.
 
 <ul>
-<li><a accesskey=1 href="#General%20Numeric">General Numeric</a>:              Parameters for formatting numbers and
+<li><a accesskey=1 href="#General Numeric">General Numeric</a>:              Parameters for formatting numbers and
                                  currency amounts. 
-<li><a accesskey=2 href="#Currency%20Symbol">Currency Symbol</a>:              How to print the symbol that identifies an
+<li><a accesskey=2 href="#Currency Symbol">Currency Symbol</a>:              How to print the symbol that identifies an
                                  amount of money (e.g. <code>$</code>). 
-<li><a accesskey=3 href="#Sign%20of%20Money%20Amount">Sign of Money Amount</a>:         How to print the (positive or negative) sign
+<li><a accesskey=3 href="#Sign of Money Amount">Sign of Money Amount</a>:         How to print the (positive or negative) sign
                                  for a monetary amount, if one exists. 
 </ul>
 
 <p><hr>
-Node:<a name="General%20Numeric">General Numeric</a>,
-Next:<a rel=next accesskey=n href="#Currency%20Symbol">Currency Symbol</a>,
-Up:<a rel=up accesskey=u href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>
+Node:<a name="General Numeric">General Numeric</a>,
+Next:<a rel=next accesskey=n href="#Currency Symbol">Currency Symbol</a>,
+Up:<a rel=up accesskey=u href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>
 <br>
 
 <h5>Generic Numeric Formatting Parameters</h5>
 
@@ -16348,12 +15950,12 @@
 confusing!) 
 </dl>
 
 <p><hr>
-Node:<a name="Currency%20Symbol">Currency Symbol</a>,
-Next:<a rel=next accesskey=n href="#Sign%20of%20Money%20Amount">Sign of Money Amount</a>,
-Previous:<a rel=previous accesskey=p href="#General%20Numeric">General Numeric</a>,
-Up:<a rel=up accesskey=u href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>
+Node:<a name="Currency Symbol">Currency Symbol</a>,
+Next:<a rel=next accesskey=n href="#Sign of Money Amount">Sign of Money Amount</a>,
+Previous:<a rel=previous accesskey=p href="#General Numeric">General Numeric</a>,
+Up:<a rel=up accesskey=u href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>
 <br>
 
 <h5>Printing the Currency Symbol</h5>
 
@@ -16445,11 +16047,11 @@
 string). 
 </dl>
 
 <p><hr>
-Node:<a name="Sign%20of%20Money%20Amount">Sign of Money Amount</a>,
-Previous:<a rel=previous accesskey=p href="#Currency%20Symbol">Currency Symbol</a>,
-Up:<a rel=up accesskey=u href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>
+Node:<a name="Sign of Money Amount">Sign of Money Amount</a>,
+Previous:<a rel=previous accesskey=p href="#Currency Symbol">Currency Symbol</a>,
+Up:<a rel=up accesskey=u href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>
 <br>
 
 <h5>Printing the Sign of a Monetary Amount</h5>
 
@@ -16512,11 +16114,11 @@
 <code>currency_symbol</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>,
-Previous:<a rel=previous accesskey=p href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>,
-Up:<a rel=up accesskey=u href="#Locale%20Information">Locale Information</a>
+Node:<a name="The Elegant and Fast Way">The Elegant and Fast Way</a>,
+Previous:<a rel=previous accesskey=p href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>,
+Up:<a rel=up accesskey=u href="#Locale Information">Locale Information</a>
 <br>
 
 <h4>Pinpoint Access to Locale Data</h4>
 
@@ -16527,16 +16129,15 @@
 ways to access it.  Therefore the <code>nl_langinfo</code> function
 was introduced.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>nl_langinfo</b><i> (nl_item <var>item</var>)
-</i></td>
+<td align="left"><code>char * <b>nl_langinfo</b><i> (nl_item <var>item</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>nl_langinfo</code> function can be used to access individual
 elements of the locale categories.  Unlike the <code>localeconv</code>
 function, which returns all the information, <code>nl_langinfo</code>
@@ -16756,9 +16357,9 @@
 to a yes/no question.
 
 <p>Using this value is deprecated since it is a very special case of
 message translation, and is better handled by the message
-translation functions (see <a href="#Message%20Translation">Message Translation</a>).
+translation functions (see <a href="#Message Translation">Message Translation</a>).
 
 <p>The use of this symbol is deprecated.  Instead message translation
 should be used. 
 <br><dt><code>NOSTR</code>
@@ -16816,11 +16417,11 @@
 correctly there should never be a misunderstanding over the time and
 date format.
 
 <p><hr>
-Node:<a name="Formatting%20Numbers">Formatting Numbers</a>,
-Next:<a rel=next accesskey=n href="#Yes-or-No%20Questions">Yes-or-No Questions</a>,
-Previous:<a rel=previous accesskey=p href="#Locale%20Information">Locale Information</a>,
+Node:<a name="Formatting Numbers">Formatting Numbers</a>,
+Next:<a rel=next accesskey=n href="#Yes-or-No Questions">Yes-or-No Questions</a>,
+Previous:<a rel=previous accesskey=p href="#Locale Information">Locale Information</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>A dedicated function to format numbers</h3>
@@ -16834,16 +16435,15 @@
 locale information, making it easier for the user to format
 numbers according to these rules.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>strfmon</b><i> (char *<var>s</var>, size_t <var>maxsize</var>, const char *<var>format</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>ssize_t <b>strfmon</b><i> (char *<var>s</var>, size_t <var>maxsize</var>, const char *<var>format</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strfmon</code> function is similar to the <code>strftime</code> function
 in that it takes a buffer, its size, a format string,
 and values to write into the buffer as text in a form specified
@@ -16911,9 +16511,9 @@
 <p>The second optional field starts with a <code>.</code> (period) and consists
 of another decimal digit string.  Its value describes the number of
 characters printed after the decimal point.  The default is selected
 from the current locale (<code>frac_digits</code>, <code>int_frac_digits</code>, see
-see <a href="#General%20Numeric">General Numeric</a>).  If the exact representation needs more digits
+see <a href="#General Numeric">General Numeric</a>).  If the exact representation needs more digits
 than given by the field width, the displayed value is rounded.  If the
 number of fractional digits is selected to be zero, no decimal point is
 printed.
 
@@ -17028,10 +16628,10 @@
 printed with an extra zero at the end and the third number is printed
 without rounding.
 
 <p><hr>
-Node:<a name="Yes-or-No%20Questions">Yes-or-No Questions</a>,
-Previous:<a rel=previous accesskey=p href="#Formatting%20Numbers">Formatting Numbers</a>,
+Node:<a name="Yes-or-No Questions">Yes-or-No Questions</a>,
+Previous:<a rel=previous accesskey=p href="#Formatting Numbers">Formatting Numbers</a>,
 Up:<a rel=up accesskey=u href="#Locales">Locales</a>
 <br>
 
 <h3>Yes-or-No Questions</h3>
@@ -17045,16 +16645,15 @@
 <p>The GNU C library contains <code>rpmatch</code> to give applications easy
 access to the corresponding locale definitions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>rpmatch</b><i> (const char *<var>response</var>)
-</i></td>
+<td align="left"><code>int <b>rpmatch</b><i> (const char *<var>response</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>rpmatch</code> checks the string in <var>response</var> whether
 or not it is a correct yes-or-no answer and if yes, which one.  The
 check uses the <code>YESEXPR</code> and <code>NOEXPR</code> data in the
@@ -17108,10 +16707,10 @@
 <p>Note that the loop continues until an read error is detected or until a
 definitive (positive or negative) answer is read.
 
 <p><hr>
-Node:<a name="Message%20Translation">Message Translation</a>,
-Next:<a rel=next accesskey=n href="#Searching%20and%20Sorting">Searching and Sorting</a>,
+Node:<a name="Message Translation">Message Translation</a>,
+Next:<a rel=next accesskey=n href="#Searching and Sorting">Searching and Sorting</a>,
 Previous:<a rel=previous accesskey=p href="#Locales">Locales</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -17154,16 +16753,16 @@
 <p>The two approaches mainly differ in the implementation of this last
 step.  The design decisions made for this influences the whole rest.
 
 <ul>
-<li><a accesskey=1 href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>:   The <code>catgets</code> family of functions. 
-<li><a accesskey=2 href="#The%20Uniforum%20approach">The Uniforum approach</a>:          The <code>gettext</code> family of functions. 
+<li><a accesskey=1 href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>:   The <code>catgets</code> family of functions. 
+<li><a accesskey=2 href="#The Uniforum approach">The Uniforum approach</a>:          The <code>gettext</code> family of functions. 
 </ul>
 
 <p><hr>
-Node:<a name="Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>,
-Next:<a rel=next accesskey=n href="#The%20Uniforum%20approach">The Uniforum approach</a>,
-Up:<a rel=up accesskey=u href="#Message%20Translation">Message Translation</a>
+Node:<a name="Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>,
+Next:<a rel=next accesskey=n href="#The Uniforum approach">The Uniforum approach</a>,
+Up:<a rel=up accesskey=u href="#Message Translation">Message Translation</a>
 <br>
 
 <h3>X/Open Message Catalog Handling</h3>
 
@@ -17187,32 +16786,31 @@
 <p>All the types, constants and functions for the <code>catgets</code> functions
 are defined/declared in the <code>nl_types.h</code> header file.
 
 <ul>
-<li><a accesskey=1 href="#The%20catgets%20Functions">The catgets Functions</a>:       The <code>catgets</code> function family. 
-<li><a accesskey=2 href="#The%20message%20catalog%20files">The message catalog files</a>:   Format of the message catalog files. 
-<li><a accesskey=3 href="#The%20gencat%20program">The gencat program</a>:          How to generate message catalogs files which
+<li><a accesskey=1 href="#The catgets Functions">The catgets Functions</a>:       The <code>catgets</code> function family. 
+<li><a accesskey=2 href="#The message catalog files">The message catalog files</a>:   Format of the message catalog files. 
+<li><a accesskey=3 href="#The gencat program">The gencat program</a>:          How to generate message catalogs files which
                                 can be used by the functions. 
-<li><a accesskey=4 href="#Common%20Usage">Common Usage</a>:                How to use the <code>catgets</code> interface. 
+<li><a accesskey=4 href="#Common Usage">Common Usage</a>:                How to use the <code>catgets</code> interface. 
 </ul>
 
 <p><hr>
-Node:<a name="The%20catgets%20Functions">The catgets Functions</a>,
-Next:<a rel=next accesskey=n href="#The%20message%20catalog%20files">The message catalog files</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>
+Node:<a name="The catgets Functions">The catgets Functions</a>,
+Next:<a rel=next accesskey=n href="#The message catalog files">The message catalog files</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>
 <br>
 
 <h4>The <code>catgets</code> function family</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">nl_catd <b>catopen</b><i> (const char *<var>cat_name</var>, int <var>flag</var>)
-</i></td>
+<td align="left"><code>nl_catd <b>catopen</b><i> (const char *<var>cat_name</var>, int <var>flag</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>catgets</code> function tries to locate the message data file names
 <var>cat_name</var> and loads it when found.  The return value is of an
 opaque type and can be used in calls to the other functions to refer to
@@ -17305,9 +16903,9 @@
 should be written this way.  Beside this, this behavior is not portable
 to all other platforms providing the <code>catgets</code> interface.
 
 <p>Otherwise the values of environment variables from the standard
-environment are examined (see <a href="#Standard%20Environment">Standard Environment</a>).  Which
+environment are examined (see <a href="#Standard Environment">Standard Environment</a>).  Which
 variables are examined is decided by the <var>flag</var> parameter of
 <code>catopen</code>.  If the value is <code>NL_CAT_LOCALE</code> (which is defined
 in <code>nl_types.h</code>) then the <code>catopen</code> function use the name of
 the locale currently selected for the <code>LC_MESSAGES</code> category.
@@ -17359,16 +16957,15 @@
 The <code>catopen</code> function directly reads the values of the environment
 variables.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>catgets</b><i> (nl_catd <var>catalog_desc</var>, int <var>set</var>, int <var>message</var>, const char *<var>string</var>)
-</i></td>
+<td align="left"><code>char * <b>catgets</b><i> (nl_catd <var>catalog_desc</var>, int <var>set</var>, int <var>message</var>, const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>catgets</code> has to be used to access the massage catalog
 previously opened using the <code>catopen</code> function.  The
 <var>catalog_desc</var> parameter must be a value previously returned by
@@ -17401,19 +16998,18 @@
 functions if no supporting functionality is available.  Since each
 set/message number tuple must be unique the programmer must keep lists
 of the messages at the same time the code is written.  And the work
 between several people working on the same project must be coordinated. 
-We will see some how these problems can be relaxed a bit (see <a href="#Common%20Usage">Common Usage</a>).
+We will see some how these problems can be relaxed a bit (see <a href="#Common Usage">Common Usage</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>catclose</b><i> (nl_catd <var>catalog_desc</var>)
-</i></td>
+<td align="left"><code>int <b>catclose</b><i> (nl_catd <var>catalog_desc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>catclose</code> function can be used to free the resources
 associated with a message catalog which previously was opened by a call
 to <code>catopen</code>.  If the resources can be successfully freed the
@@ -17424,12 +17020,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="The%20message%20catalog%20files">The message catalog files</a>,
-Next:<a rel=next accesskey=n href="#The%20gencat%20program">The gencat program</a>,
-Previous:<a rel=previous accesskey=p href="#The%20catgets%20Functions">The catgets Functions</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>
+Node:<a name="The message catalog files">The message catalog files</a>,
+Next:<a rel=next accesskey=n href="#The gencat program">The gencat program</a>,
+Previous:<a rel=previous accesskey=p href="#The catgets Functions">The catgets Functions</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>
 <br>
 
 <h4>Format of the message catalog files</h4>
 
@@ -17458,9 +17054,9 @@
 <li>an identifier consisting of alphanumeric characters plus the underscore
 character.  In this case the set get automatically a number assigned. 
 This value is one added to the largest set number which so far appeared.
 
-<p>How to use the symbolic names is explained in section <a href="#Common%20Usage">Common Usage</a>.
+<p>How to use the symbolic names is explained in section <a href="#Common Usage">Common Usage</a>.
 
 <p>It is an error if a symbol name appears more than once.  All following
 messages are placed in a set with this number. 
 </ul>
@@ -17512,9 +17108,9 @@
 automatically assigned.  The value is the current maximum messages
 number for this set plus one.  It is an error if the identifier was
 already used for a message in this set.  It is OK to reuse the
 identifier for a message in another thread.  How to use the symbolic
-identifiers will be explained below (see <a href="#Common%20Usage">Common Usage</a>).  There is
+identifiers will be explained below (see <a href="#Common Usage">Common Usage</a>).  There is
 one limitation with the identifier: it must not be <code>Set</code>.  The
 reason will be explained below.
 
 <p>The text of the messages can contain escape characters.  The usual bunch
@@ -17571,12 +17167,12 @@
 <code>gencat</code> program and so the interested reader can look through
 these source files to learn about the file format.
 
 <p><hr>
-Node:<a name="The%20gencat%20program">The gencat program</a>,
-Next:<a rel=next accesskey=n href="#Common%20Usage">Common Usage</a>,
-Previous:<a rel=previous accesskey=p href="#The%20message%20catalog%20files">The message catalog files</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>
+Node:<a name="The gencat program">The gencat program</a>,
+Next:<a rel=next accesskey=n href="#Common Usage">Common Usage</a>,
+Previous:<a rel=previous accesskey=p href="#The message catalog files">The message catalog files</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>
 <br>
 
 <h4>Generate Message Catalogs files</h4>
 
@@ -17587,9 +17183,9 @@
 <code>catgets</code> functions.
 
 <p>The <code>gencat</code> program can be invoked in two ways:
 
-<br><pre>`gencat [<var>Option</var>]<small>...</small> [<var>Output-File</var> [<var>Input-File</var>]<small>...</small>]`
+<br><pre>'gencat [<var>Option</var>]<small>...</small> [<var>Output-File</var> [<var>Input-File</var>]<small>...</small>]'
 </pre>
 
 <p>This is the interface defined in the X/Open standard.  If no
 <var>Input-File</var> parameter is given input will be read from standard
@@ -17597,9 +17193,9 @@
 If <var>Output-File</var> is also missing, the output will be written to
 standard output.  To provide the interface one is used to from other
 programs a second interface is provided.
 
-<br><pre>`gencat [<var>Option</var>]<small>...</small> -o <var>Output-File</var> [<var>Input-File</var>]<small>...</small>`
+<br><pre>'gencat [<var>Option</var>]<small>...</small> -o <var>Output-File</var> [<var>Input-File</var>]<small>...</small>'
 </pre>
 
 <p>The option <code>-o</code> is used to specify the output file and all file
 arguments are used as input files.
@@ -17648,11 +17244,11 @@
 generated the old output files are not in the generated header file. 
 </dl>
 
 <p><hr>
-Node:<a name="Common%20Usage">Common Usage</a>,
-Previous:<a rel=previous accesskey=p href="#The%20gencat%20program">The gencat program</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>
+Node:<a name="Common Usage">Common Usage</a>,
+Previous:<a rel=previous accesskey=p href="#The gencat program">The gencat program</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>
 <br>
 
 <h4>How to use the <code>catgets</code> interface</h4>
 
@@ -17834,11 +17430,11 @@
 Please check the <code>LC_ALL</code> environment variable and the default path
 for <code>catopen</code> presented in the description above.
 
 <p><hr>
-Node:<a name="The%20Uniforum%20approach">The Uniforum approach</a>,
-Previous:<a rel=previous accesskey=p href="#Message%20catalogs%20a%20la%20X%2fOpen">Message catalogs a la X/Open</a>,
-Up:<a rel=up accesskey=u href="#Message%20Translation">Message Translation</a>
+Node:<a name="The Uniforum approach">The Uniforum approach</a>,
+Previous:<a rel=previous accesskey=p href="#Message catalogs a la X%2fOpen">Message catalogs a la X/Open</a>,
+Up:<a rel=up accesskey=u href="#Message Translation">Message Translation</a>
 <br>
 
 <h3>The Uniforum approach to Message Translation</h3>
 
@@ -17864,17 +17460,17 @@
 former.  The GNU <code>gettext</code> package can be used wherever the
 functions are not available.
 
 <ul>
-<li><a accesskey=1 href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>:   The <code>gettext</code> family of functions. 
-<li><a accesskey=2 href="#Helper%20programs%20for%20gettext">Helper programs for gettext</a>:     Programs to handle message catalogs
+<li><a accesskey=1 href="#Message catalogs with gettext">Message catalogs with gettext</a>:   The <code>gettext</code> family of functions. 
+<li><a accesskey=2 href="#Helper programs for gettext">Helper programs for gettext</a>:     Programs to handle message catalogs
                                     for <code>gettext</code>. 
 </ul>
 
 <p><hr>
-Node:<a name="Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>,
-Next:<a rel=next accesskey=n href="#Helper%20programs%20for%20gettext">Helper programs for gettext</a>,
-Up:<a rel=up accesskey=u href="#The%20Uniforum%20approach">The Uniforum approach</a>
+Node:<a name="Message catalogs with gettext">Message catalogs with gettext</a>,
+Next:<a rel=next accesskey=n href="#Helper programs for gettext">Helper programs for gettext</a>,
+Up:<a rel=up accesskey=u href="#The Uniforum approach">The Uniforum approach</a>
 <br>
 
 <h4>The <code>gettext</code> family of functions</h4>
 
@@ -17883,23 +17479,23 @@
 basic functionally is equivalent.  There are functions of the following
 categories:
 
 <ul>
-<li><a accesskey=1 href="#Translation%20with%20gettext">Translation with gettext</a>:        What has to be done to translate a message. 
-<li><a accesskey=2 href="#Locating%20gettext%20catalog">Locating gettext catalog</a>:        How to determine which catalog to be used. 
-<li><a accesskey=3 href="#Advanced%20gettext%20functions">Advanced gettext functions</a>:      Additional functions for more complicated
+<li><a accesskey=1 href="#Translation with gettext">Translation with gettext</a>:        What has to be done to translate a message. 
+<li><a accesskey=2 href="#Locating gettext catalog">Locating gettext catalog</a>:        How to determine which catalog to be used. 
+<li><a accesskey=3 href="#Advanced gettext functions">Advanced gettext functions</a>:      Additional functions for more complicated
                                     situations. 
-<li><a accesskey=4 href="#Charset%20conversion%20in%20gettext">Charset conversion in gettext</a>:   How to specify the output character set
+<li><a accesskey=4 href="#Charset conversion in gettext">Charset conversion in gettext</a>:   How to specify the output character set
                                     <code>gettext</code> uses. 
-<li><a accesskey=5 href="#GUI%20program%20problems">GUI program problems</a>:            How to use <code>gettext</code> in GUI programs. 
-<li><a accesskey=6 href="#Using%20gettextized%20software">Using gettextized software</a>:      The possibilities of the user to influence
+<li><a accesskey=5 href="#GUI program problems">GUI program problems</a>:            How to use <code>gettext</code> in GUI programs. 
+<li><a accesskey=6 href="#Using gettextized software">Using gettextized software</a>:      The possibilities of the user to influence
                                     the way <code>gettext</code> works. 
 </ul>
 
 <p><hr>
-Node:<a name="Translation%20with%20gettext">Translation with gettext</a>,
-Next:<a rel=next accesskey=n href="#Locating%20gettext%20catalog">Locating gettext catalog</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>
+Node:<a name="Translation with gettext">Translation with gettext</a>,
+Next:<a rel=next accesskey=n href="#Locating gettext catalog">Locating gettext catalog</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs with gettext">Message catalogs with gettext</a>
 <br>
 
 <h5>What has to be done to translate a message?</h5>
 
@@ -17928,16 +17524,15 @@
 not part of the C library they can be found in a separate library named
 <code>libintl.a</code> (or accordingly different for shared libraries).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>gettext</b><i> (const char *<var>msgid</var>)
-</i></td>
+<td align="left"><code>char * <b>gettext</b><i> (const char *<var>msgid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gettext</code> function searches the currently selected message
 catalogs for a string which is equal to <var>msgid</var>.  If there is such a
 string available it is returned.  Otherwise the argument string
@@ -17950,9 +17545,9 @@
 
 <p>Please note that above we wrote "message catalogs" (plural).  This is
 a specialty of the GNU implementation of these functions and we will
 say more about this when we talk about the ways message catalogs are
-selected (see <a href="#Locating%20gettext%20catalog">Locating gettext catalog</a>).
+selected (see <a href="#Locating gettext catalog">Locating gettext catalog</a>).
 
 <p>The <code>gettext</code> function does not modify the value of the global
 <var>errno</var> variable.  This is necessary to make it possible to write
 something like
@@ -17982,16 +17577,15 @@
 currently selected default message catalog it must specify all ambiguous
 information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>dgettext</b><i> (const char *<var>domainname</var>, const char *<var>msgid</var>)
-</i></td>
+<td align="left"><code>char * <b>dgettext</b><i> (const char *<var>domainname</var>, const char *<var>msgid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>dgettext</code> functions acts just like the <code>gettext</code>
 function.  It only takes an additional first argument <var>domainname</var>
 which guides the selection of the message catalogs which are searched
@@ -18004,16 +17598,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>dcgettext</b><i> (const char *<var>domainname</var>, const char *<var>msgid</var>, int <var>category</var>)
-</i></td>
+<td align="left"><code>char * <b>dcgettext</b><i> (const char *<var>domainname</var>, const char *<var>msgid</var>, int <var>category</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>dcgettext</code> adds another argument to those which
 <code>dgettext</code> takes.  This argument <var>category</var> specifies the last
 piece of information needed to localize the message catalog.  I.e., the
@@ -18057,12 +17650,12 @@
 will not change.  This optimization is actually implemented by the
 <code>gettext</code>, <code>dgettext</code> and <code>dcgettext</code> functions.
 
 <p><hr>
-Node:<a name="Locating%20gettext%20catalog">Locating gettext catalog</a>,
-Next:<a rel=next accesskey=n href="#Advanced%20gettext%20functions">Advanced gettext functions</a>,
-Previous:<a rel=previous accesskey=p href="#Translation%20with%20gettext">Translation with gettext</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>
+Node:<a name="Locating gettext catalog">Locating gettext catalog</a>,
+Next:<a rel=next accesskey=n href="#Advanced gettext functions">Advanced gettext functions</a>,
+Previous:<a rel=previous accesskey=p href="#Translation with gettext">Translation with gettext</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs with gettext">Message catalogs with gettext</a>
 <br>
 
 <h5>How to determine which catalog to be used</h5>
 
@@ -18133,16 +17726,15 @@
 exactly one domain is active.  This is controlled with the following
 function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>textdomain</b><i> (const char *<var>domainname</var>)
-</i></td>
+<td align="left"><code>char * <b>textdomain</b><i> (const char *<var>domainname</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>textdomain</code> function sets the default domain, which is used in
 all future <code>gettext</code> calls, to <var>domainname</var>.  Please note that
 <code>dgettext</code> and <code>dcgettext</code> calls are not influenced if the
@@ -18172,16 +17764,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>bindtextdomain</b><i> (const char *<var>domainname</var>, const char *<var>dirname</var>)
-</i></td>
+<td align="left"><code>char * <b>bindtextdomain</b><i> (const char *<var>domainname</var>, const char *<var>dirname</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>bindtextdomain</code> function can be used to specify the directory
 which contains the message catalogs for domain <var>domainname</var> for the
 different languages.  To be correct, this is the directory where the
@@ -18218,12 +17809,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Advanced%20gettext%20functions">Advanced gettext functions</a>,
-Next:<a rel=next accesskey=n href="#Charset%20conversion%20in%20gettext">Charset conversion in gettext</a>,
-Previous:<a rel=previous accesskey=p href="#Locating%20gettext%20catalog">Locating gettext catalog</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>
+Node:<a name="Advanced gettext functions">Advanced gettext functions</a>,
+Next:<a rel=next accesskey=n href="#Charset conversion in gettext">Charset conversion in gettext</a>,
+Previous:<a rel=previous accesskey=p href="#Locating gettext catalog">Locating gettext catalog</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs with gettext">Message catalogs with gettext</a>
 <br>
 
 <h5>Additional functions for more complicated situations</h5>
 
@@ -18250,9 +17841,9 @@
      printf ("%d files deleted", n);
 </pre>
 
 <p>But this does not solve the problem.  It helps languages where the
-plural form of a noun is not simply constructed by adding an `s' but
+plural form of a noun is not simply constructed by adding an 's' but
 that is all.  Once again people fell into the trap of believing the
 rules their language is using are universal.  But the handling of plural
 forms differs widely between the language families.  There are two
 things we can differ between (and even inside language families);
@@ -18261,9 +17852,9 @@
 <li>The form how plural forms are build differs.  This is a problem with
 language which have many irregularities.  German, for instance, is a
 drastic case.  Though English and German are part of the same language
 family (Germanic), the almost regular forming of plural noun forms
-(appending an `s') is hardly found in German.
+(appending an 's') is hardly found in German.
 
 <li>The number of plural forms differ.  This is somewhat surprising for
 those who only have experiences with Romanic and Germanic languages
 since here the number is the same (there are two).
@@ -18295,16 +17886,15 @@
 being written in English, this solution nevertheless fulfills its
 purpose.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ngettext</b><i> (const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>)
-</i></td>
+<td align="left"><code>char * <b>ngettext</b><i> (const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ngettext</code> function is similar to the <code>gettext</code> function
 as it finds the message catalogs in the same way.  But it takes two
 extra arguments.  The <var>msgid1</var> parameter must contain the singular
@@ -18325,16 +17915,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>dngettext</b><i> (const char *<var>domain</var>, const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>)
-</i></td>
+<td align="left"><code>char * <b>dngettext</b><i> (const char *<var>domain</var>, const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>dngettext</code> is similar to the <code>dgettext</code> function in the
 way the message catalog is selected.  The difference is that it takes
 two extra parameter to provide the correct plural form.  These two
@@ -18342,16 +17931,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>dcngettext</b><i> (const char *<var>domain</var>, const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>, int <var>category</var>)
-</i></td>
+<td align="left"><code>char * <b>dcngettext</b><i> (const char *<var>domain</var>, const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>, int <var>category</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>dcngettext</code> is similar to the <code>dcgettext</code> function in the
 way the message catalog is selected.  The difference is that it takes
 two extra parameter to provide the correct plural form.  These two
@@ -18533,12 +18121,12 @@
 </dl>
 </dl>
 
 <p><hr>
-Node:<a name="Charset%20conversion%20in%20gettext">Charset conversion in gettext</a>,
-Next:<a rel=next accesskey=n href="#GUI%20program%20problems">GUI program problems</a>,
-Previous:<a rel=previous accesskey=p href="#Advanced%20gettext%20functions">Advanced gettext functions</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>
+Node:<a name="Charset conversion in gettext">Charset conversion in gettext</a>,
+Next:<a rel=next accesskey=n href="#GUI program problems">GUI program problems</a>,
+Previous:<a rel=previous accesskey=p href="#Advanced gettext functions">Advanced gettext functions</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs with gettext">Message catalogs with gettext</a>
 <br>
 
 <h5>How to specify the output character set <code>gettext</code> uses</h5>
 
@@ -18562,16 +18150,15 @@
 independently of the current output character set.  It is therefore
 recommended that all <var>msgid</var>s be US-ASCII strings.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>bind_textdomain_codeset</b><i> (const char *<var>domainname</var>, const char *<var>codeset</var>)
-</i></td>
+<td align="left"><code>char * <b>bind_textdomain_codeset</b><i> (const char *<var>domainname</var>, const char *<var>codeset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>bind_textdomain_codeset</code> function can be used to specify the
 output character set for message catalogs for domain <var>domainname</var>. 
 The <var>codeset</var> argument must be a valid codeset name which can be used
@@ -18594,12 +18181,12 @@
 global variable <var>errno</var> is set accordingly.  </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="GUI%20program%20problems">GUI program problems</a>,
-Next:<a rel=next accesskey=n href="#Using%20gettextized%20software">Using gettextized software</a>,
-Previous:<a rel=previous accesskey=p href="#Charset%20conversion%20in%20gettext">Charset conversion in gettext</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>
+Node:<a name="GUI program problems">GUI program problems</a>,
+Next:<a rel=next accesskey=n href="#Using gettextized software">Using gettextized software</a>,
+Previous:<a rel=previous accesskey=p href="#Charset conversion in gettext">Charset conversion in gettext</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs with gettext">Message catalogs with gettext</a>
 <br>
 
 <h5>How to use <code>gettext</code> in GUI programs</h5>
 
@@ -18724,11 +18311,11 @@
 (since they are never used as keys for a search) and one also saves
 quite some memory and disk space by doing this.
 
 <p><hr>
-Node:<a name="Using%20gettextized%20software">Using gettextized software</a>,
-Previous:<a rel=previous accesskey=p href="#GUI%20program%20problems">GUI program problems</a>,
-Up:<a rel=up accesskey=u href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>
+Node:<a name="Using gettextized software">Using gettextized software</a>,
+Previous:<a rel=previous accesskey=p href="#GUI program problems">GUI program problems</a>,
+Up:<a rel=up accesskey=u href="#Message catalogs with gettext">Message catalogs with gettext</a>
 <br>
 
 <h5>User influence on <code>gettext</code></h5>
 
@@ -18930,11 +18517,11 @@
 message catalogs there are files for the same language but coded using
 different character sets the user has to be careful.
 
 <p><hr>
-Node:<a name="Helper%20programs%20for%20gettext">Helper programs for gettext</a>,
-Previous:<a rel=previous accesskey=p href="#Message%20catalogs%20with%20gettext">Message catalogs with gettext</a>,
-Up:<a rel=up accesskey=u href="#The%20Uniforum%20approach">The Uniforum approach</a>
+Node:<a name="Helper programs for gettext">Helper programs for gettext</a>,
+Previous:<a rel=previous accesskey=p href="#Message catalogs with gettext">Message catalogs with gettext</a>,
+Up:<a rel=up accesskey=u href="#The Uniforum approach">The Uniforum approach</a>
 <br>
 
 <h4>Programs to handle message catalogs for <code>gettext</code></h4>
 
@@ -18967,11 +18554,11 @@
 generating the translations the developers do not have anything to do
 themselves.
 
 <p><hr>
-Node:<a name="Searching%20and%20Sorting">Searching and Sorting</a>,
-Next:<a rel=next accesskey=n href="#Pattern%20Matching">Pattern Matching</a>,
-Previous:<a rel=previous accesskey=p href="#Message%20Translation">Message Translation</a>,
+Node:<a name="Searching and Sorting">Searching and Sorting</a>,
+Next:<a rel=next accesskey=n href="#Pattern Matching">Pattern Matching</a>,
+Previous:<a rel=previous accesskey=p href="#Message Translation">Message Translation</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Searching and Sorting</h2>
@@ -18981,23 +18568,23 @@
 applied as an argument, along with the size of the objects in the array
 and the total number of elements.
 
 <ul>
-<li><a accesskey=1 href="#Comparison%20Functions">Comparison Functions</a>:         Defining how to compare two objects. 
+<li><a accesskey=1 href="#Comparison Functions">Comparison Functions</a>:         Defining how to compare two objects. 
 				 Since the sort and search facilities
                                  are general, you have to specify the
                                  ordering. 
-<li><a accesskey=2 href="#Array%20Search%20Function">Array Search Function</a>:        The <code>bsearch</code> function. 
-<li><a accesskey=3 href="#Array%20Sort%20Function">Array Sort Function</a>:          The <code>qsort</code> function. 
-<li><a accesskey=4 href="#Search%2fSort%20Example">Search/Sort Example</a>:          An example program. 
-<li><a accesskey=5 href="#Hash%20Search%20Function">Hash Search Function</a>:         The <code>hsearch</code> function. 
-<li><a accesskey=6 href="#Tree%20Search%20Function">Tree Search Function</a>:         The <code>tsearch</code> function. 
+<li><a accesskey=2 href="#Array Search Function">Array Search Function</a>:        The <code>bsearch</code> function. 
+<li><a accesskey=3 href="#Array Sort Function">Array Sort Function</a>:          The <code>qsort</code> function. 
+<li><a accesskey=4 href="#Search%2fSort Example">Search/Sort Example</a>:          An example program. 
+<li><a accesskey=5 href="#Hash Search Function">Hash Search Function</a>:         The <code>hsearch</code> function. 
+<li><a accesskey=6 href="#Tree Search Function">Tree Search Function</a>:         The <code>tsearch</code> function. 
 </ul>
 
 <p><hr>
-Node:<a name="Comparison%20Functions">Comparison Functions</a>,
-Next:<a rel=next accesskey=n href="#Array%20Search%20Function">Array Search Function</a>,
-Up:<a rel=up accesskey=u href="#Searching%20and%20Sorting">Searching and Sorting</a>
+Node:<a name="Comparison Functions">Comparison Functions</a>,
+Next:<a rel=next accesskey=n href="#Array Search Function">Array Search Function</a>,
+Up:<a rel=up accesskey=u href="#Searching and Sorting">Searching and Sorting</a>
 <br>
 
 <h3>Defining the Comparison Function</h3>
 
@@ -19006,9 +18593,9 @@
 
 <p>To do this, you supply a comparison function to compare two elements of
 the array.  The library will call this function, passing as arguments
 pointers to two array elements to be compared.  Your comparison function
-should return a value the way <code>strcmp</code> (see <a href="#String%2fArray%20Comparison">String/Array Comparison</a>) does: negative if the first argument is "less" than the
+should return a value the way <code>strcmp</code> (see <a href="#String%2fArray Comparison">String/Array Comparison</a>) does: negative if the first argument is "less" than the
 second, zero if they are "equal", and positive if the first argument
 is "greater".
 
 <p>Here is an example of a comparison function which works with an array of
@@ -19030,12 +18617,12 @@
 <br><pre>int comparison_fn_t (const void *, const void *);
 </pre>
 
 <p><hr>
-Node:<a name="Array%20Search%20Function">Array Search Function</a>,
-Next:<a rel=next accesskey=n href="#Array%20Sort%20Function">Array Sort Function</a>,
-Previous:<a rel=previous accesskey=p href="#Comparison%20Functions">Comparison Functions</a>,
-Up:<a rel=up accesskey=u href="#Searching%20and%20Sorting">Searching and Sorting</a>
+Node:<a name="Array Search Function">Array Search Function</a>,
+Next:<a rel=next accesskey=n href="#Array Sort Function">Array Sort Function</a>,
+Previous:<a rel=previous accesskey=p href="#Comparison Functions">Comparison Functions</a>,
+Up:<a rel=up accesskey=u href="#Searching and Sorting">Searching and Sorting</a>
 <br>
 
 <h3>Array Search Function</h3>
 
@@ -19044,16 +18631,15 @@
 functions to perform linear search.  The prototypes for the following
 two functions can be found in <code>search.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>lfind</b><i> (const void *<var>key</var>, void *<var>base</var>, size_t *<var>nmemb</var>, size_t <var>size</var>, comparison_fn_t <var>compar</var>)
-</i></td>
+<td align="left"><code>void * <b>lfind</b><i> (const void *<var>key</var>, void *<var>base</var>, size_t *<var>nmemb</var>, size_t <var>size</var>, comparison_fn_t <var>compar</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lfind</code> function searches in the array with <code>*<var>nmemb</var></code>
 elements of <var>size</var> bytes pointed to by <var>base</var> for an element
 which matches the one pointed to by <var>key</var>.  The function pointed to
@@ -19070,16 +18656,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>lsearch</b><i> (const void *<var>key</var>, void *<var>base</var>, size_t *<var>nmemb</var>, size_t <var>size</var>, comparison_fn_t <var>compar</var>)
-</i></td>
+<td align="left"><code>void * <b>lsearch</b><i> (const void *<var>key</var>, void *<var>base</var>, size_t *<var>nmemb</var>, size_t <var>size</var>, comparison_fn_t <var>compar</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lsearch</code> function is similar to the <code>lfind</code> function.  It
 searches the given array for an element and returns it if found.  The
 difference is that if no matching element is found the <code>lsearch</code>
@@ -19100,16 +18685,15 @@
 <code>bsearch</code> function.  The prototype for this function is in
 the header file <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>bsearch</b><i> (const void *<var>key</var>, const void *<var>array</var>, size_t <var>count</var>, size_t <var>size</var>, comparison_fn_t <var>compare</var>)
-</i></td>
+<td align="left"><code>void * <b>bsearch</b><i> (const void *<var>key</var>, const void *<var>array</var>, size_t <var>count</var>, size_t <var>size</var>, comparison_fn_t <var>compare</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>bsearch</code> function searches the sorted array <var>array</var> for an object
 that is equivalent to <var>key</var>.  The array contains <var>count</var> elements,
 each of which is of size <var>size</var> bytes.
@@ -19130,12 +18714,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Array%20Sort%20Function">Array Sort Function</a>,
-Next:<a rel=next accesskey=n href="#Search%2fSort%20Example">Search/Sort Example</a>,
-Previous:<a rel=previous accesskey=p href="#Array%20Search%20Function">Array Search Function</a>,
-Up:<a rel=up accesskey=u href="#Searching%20and%20Sorting">Searching and Sorting</a>
+Node:<a name="Array Sort Function">Array Sort Function</a>,
+Next:<a rel=next accesskey=n href="#Search%2fSort Example">Search/Sort Example</a>,
+Previous:<a rel=previous accesskey=p href="#Array Search Function">Array Search Function</a>,
+Up:<a rel=up accesskey=u href="#Searching and Sorting">Searching and Sorting</a>
 <br>
 
 <h3>Array Sort Function</h3>
 
@@ -19143,16 +18727,15 @@
 <code>qsort</code> function.  The prototype for this function is in
 <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>qsort</b><i> (void *<var>array</var>, size_t <var>count</var>, size_t <var>size</var>, comparison_fn_t <var>compare</var>)
-</i></td>
+<td align="left"><code>void <b>qsort</b><i> (void *<var>array</var>, size_t <var>count</var>, size_t <var>size</var>, comparison_fn_t <var>compare</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <var>qsort</var> function sorts the array <var>array</var>.  The array contains
 <var>count</var> elements, each of which is of size <var>size</var>.
 
@@ -19174,9 +18757,9 @@
 Note that doing this may make the sorting algorithm less efficient, so
 do it only if necessary.
 
 <p>Here is a simple example of sorting an array of doubles in numerical
-order, using the comparison function defined above (see <a href="#Comparison%20Functions">Comparison Functions</a>):
+order, using the comparison function defined above (see <a href="#Comparison Functions">Comparison Functions</a>):
 
 <br><pre>{
   double *array;
   int size;
@@ -19194,12 +18777,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Search%2fSort%20Example">Search/Sort Example</a>,
-Next:<a rel=next accesskey=n href="#Hash%20Search%20Function">Hash Search Function</a>,
-Previous:<a rel=previous accesskey=p href="#Array%20Sort%20Function">Array Sort Function</a>,
-Up:<a rel=up accesskey=u href="#Searching%20and%20Sorting">Searching and Sorting</a>
+Node:<a name="Search%2fSort Example">Search/Sort Example</a>,
+Next:<a rel=next accesskey=n href="#Hash Search Function">Hash Search Function</a>,
+Previous:<a rel=previous accesskey=p href="#Array Sort Function">Array Sort Function</a>,
+Up:<a rel=up accesskey=u href="#Searching and Sorting">Searching and Sorting</a>
 <br>
 
 <h3>Searching and Sorting Example</h3>
 
@@ -19342,12 +18925,12 @@
 Couldn't find Janice.
 </pre>
 
 <p><hr>
-Node:<a name="Hash%20Search%20Function">Hash Search Function</a>,
-Next:<a rel=next accesskey=n href="#Tree%20Search%20Function">Tree Search Function</a>,
-Previous:<a rel=previous accesskey=p href="#Search%2fSort%20Example">Search/Sort Example</a>,
-Up:<a rel=up accesskey=u href="#Searching%20and%20Sorting">Searching and Sorting</a>
+Node:<a name="Hash Search Function">Hash Search Function</a>,
+Next:<a rel=next accesskey=n href="#Tree Search Function">Tree Search Function</a>,
+Previous:<a rel=previous accesskey=p href="#Search%2fSort Example">Search/Sort Example</a>,
+Up:<a rel=up accesskey=u href="#Searching and Sorting">Searching and Sorting</a>
 <br>
 
 <h3>The <code>hsearch</code> function.</h3>
 
@@ -19356,16 +18939,15 @@
 which later should be searched.  The costs of insert, delete and search
 differ.  One possible implementation is using hashing tables.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>hcreate</b><i> (size_t <var>nel</var>)
-</i></td>
+<td align="left"><code>int <b>hcreate</b><i> (size_t <var>nel</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>hcreate</code> function creates a hashing table which can contain at
 least <var>nel</var> elements.  There is no possibility to grow this table so
 it is necessary to choose the value for <var>nel</var> wisely.  The used
@@ -19393,16 +18975,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>hdestroy</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>hdestroy</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>hdestroy</code> function can be used to free all the resources
 allocated in a previous call of <code>hcreate</code>.  After a call to this
 function it is again possible to call <code>hcreate</code> and allocate a new
@@ -19426,16 +19007,15 @@
 <p>Entries of the hashing table and keys for the search are defined using
 this type:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct ENTRY</b><i>
-</i></td>
+<td align="left"><code><b>struct ENTRY</b><i></i></code></td>
 <td align="right">Data type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Both elements of this structure are pointers to zero-terminated strings. 
 This is a limiting restriction of the functionality of the
 <code>hsearch</code> functions.  They can only be used for data sets which use
@@ -19454,16 +19034,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ENTRY * <b>hsearch</b><i> (ENTRY <var>item</var>, ACTION <var>action</var>)
-</i></td>
+<td align="left"><code>ENTRY * <b>hsearch</b><i> (ENTRY <var>item</var>, ACTION <var>action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 To search in a hashing table created using <code>hcreate</code> the
 <code>hsearch</code> function must be used.  This function can perform simple
 search for an element (if <var>action</var> has the <code>FIND</code>) or it can
@@ -19492,16 +19071,15 @@
 hsearch_data</code>.  This type should be treated as opaque, none of its
 members should be changed directly.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>hcreate_r</b><i> (size_t <var>nel</var>, struct hsearch_data *<var>htab</var>)
-</i></td>
+<td align="left"><code>int <b>hcreate_r</b><i> (size_t <var>nel</var>, struct hsearch_data *<var>htab</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>hcreate_r</code> function initializes the object pointed to by
 <var>htab</var> to contain a hashing table with at least <var>nel</var> elements. 
 So this function is equivalent to the <code>hcreate</code> function except
@@ -19517,16 +19095,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>hdestroy_r</b><i> (struct hsearch_data *<var>htab</var>)
-</i></td>
+<td align="left"><code>void <b>hdestroy_r</b><i> (struct hsearch_data *<var>htab</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>hdestroy_r</code> function frees all resources allocated by the
 <code>hcreate_r</code> function for this very same object <var>htab</var>.  As for
 <code>hdestroy</code> it is the programs responsibility to free the strings
@@ -19534,16 +19111,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>hsearch_r</b><i> (ENTRY <var>item</var>, ACTION <var>action</var>, ENTRY **<var>retval</var>, struct hsearch_data *<var>htab</var>)
-</i></td>
+<td align="left"><code>int <b>hsearch_r</b><i> (ENTRY <var>item</var>, ACTION <var>action</var>, ENTRY **<var>retval</var>, struct hsearch_data *<var>htab</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>hsearch_r</code> function is equivalent to <code>hsearch</code>.  The
 meaning of the first two arguments is identical.  But instead of
 operating on a single global hashing table the function works on the
@@ -19569,11 +19145,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Tree%20Search%20Function">Tree Search Function</a>,
-Previous:<a rel=previous accesskey=p href="#Hash%20Search%20Function">Hash Search Function</a>,
-Up:<a rel=up accesskey=u href="#Searching%20and%20Sorting">Searching and Sorting</a>
+Node:<a name="Tree Search Function">Tree Search Function</a>,
+Previous:<a rel=previous accesskey=p href="#Hash Search Function">Hash Search Function</a>,
+Up:<a rel=up accesskey=u href="#Searching and Sorting">Searching and Sorting</a>
 <br>
 
 <h3>The <code>tsearch</code> function.</h3>
 
@@ -19595,21 +19171,20 @@
 <code>void *</code> initialized to <code>NULL</code> is a valid tree and can be
 extended or searched.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>tsearch</b><i> (const void *<var>key</var>, void **<var>rootp</var>, comparison_fn_t <var>compar</var>)
-</i></td>
+<td align="left"><code>void * <b>tsearch</b><i> (const void *<var>key</var>, void **<var>rootp</var>, comparison_fn_t <var>compar</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>tsearch</code> function searches in the tree pointed to by
 <code>*<var>rootp</var></code> for an element matching <var>key</var>.  The function
 pointed to by <var>compar</var> is used to determine whether two elements
-match.  See <a href="#Comparison%20Functions">Comparison Functions</a>, for a specification of the functions
+match.  See <a href="#Comparison Functions">Comparison Functions</a>, for a specification of the functions
 which can be used for the <var>compar</var> parameter.
 
 <p>If the tree does not contain a matching entry the <var>key</var> value will
 be added to the tree.  <code>tsearch</code> does not make a copy of the object
@@ -19632,16 +19207,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>tfind</b><i> (const void *<var>key</var>, void *const *<var>rootp</var>, comparison_fn_t <var>compar</var>)
-</i></td>
+<td align="left"><code>void * <b>tfind</b><i> (const void *<var>key</var>, void *const *<var>rootp</var>, comparison_fn_t <var>compar</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>tfind</code> function is similar to the <code>tsearch</code> function.  It
 locates an element matching the one pointed to by <var>key</var> and returns
 a pointer to this element.  But if no matching element is available no
@@ -19654,16 +19228,15 @@
 <code>hsearch</code> functions is that there is an easy way to remove
 elements.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>tdelete</b><i> (const void *<var>key</var>, void **<var>rootp</var>, comparison_fn_t <var>compar</var>)
-</i></td>
+<td align="left"><code>void * <b>tdelete</b><i> (const void *<var>key</var>, void **<var>rootp</var>, comparison_fn_t <var>compar</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 To remove a specific element matching <var>key</var> from the tree
 <code>tdelete</code> can be used.  It locates the matching element using the
 same method as <code>tfind</code>.  The corresponding element is then removed
@@ -19675,16 +19248,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>tdestroy</b><i> (void *<var>vroot</var>, __free_fn_t <var>freefct</var>)
-</i></td>
+<td align="left"><code>void <b>tdestroy</b><i> (void *<var>vroot</var>, __free_fn_t <var>freefct</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the complete search tree has to be removed one can use
 <code>tdestroy</code>.  It frees all resources allocated by the <code>tsearch</code>
 function to generate the tree pointed to by <var>vroot</var>.
@@ -19712,20 +19284,19 @@
 root node has the depth 0 and its children have a depth of
 1 and so on.  The <code>VISIT</code> type is an enumeration type.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>VISIT</b><i>
-</i></td>
+<td align="left"><code><b>VISIT</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>VISIT</code> value indicates the status of the current node in the
 tree and how the function is called.  The status of a node is either
-`leaf' or `internal node'.  For each leaf node the function is called
+'leaf' or 'internal node'.  For each leaf node the function is called
 exactly once, for each internal node it is called three times: before
 the first child is processed, after the first child is processed and
 after both children are processed.  This makes it possible to handle all
 three methods of tree traversal (or even a combination of them).
@@ -19746,16 +19317,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>twalk</b><i> (const void *<var>root</var>, __action_fn_t <var>action</var>)
-</i></td>
+<td align="left"><code>void <b>twalk</b><i> (const void *<var>root</var>, __action_fn_t <var>action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 For each node in the tree with a node pointed to by <var>root</var>, the
 <code>twalk</code> function calls the function provided by the parameter
 <var>action</var>.  For leaf nodes the function is called exactly once with
@@ -19774,11 +19344,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Pattern%20Matching">Pattern Matching</a>,
-Next:<a rel=next accesskey=n href="#I%2fO%20Overview">I/O Overview</a>,
-Previous:<a rel=previous accesskey=p href="#Searching%20and%20Sorting">Searching and Sorting</a>,
+Node:<a name="Pattern Matching">Pattern Matching</a>,
+Next:<a rel=next accesskey=n href="#I%2fO Overview">I/O Overview</a>,
+Previous:<a rel=previous accesskey=p href="#Searching and Sorting">Searching and Sorting</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Pattern Matching</h2>
@@ -19788,20 +19358,20 @@
 provides a facility for expanding variable and command references and
 parsing text into words in the way the shell does.
 
 <ul>
-<li><a accesskey=1 href="#Wildcard%20Matching">Wildcard Matching</a>:     Matching a wildcard pattern against a single string. 
+<li><a accesskey=1 href="#Wildcard Matching">Wildcard Matching</a>:     Matching a wildcard pattern against a single string. 
 <li><a accesskey=2 href="#Globbing">Globbing</a>:              Finding the files that match a wildcard pattern. 
-<li><a accesskey=3 href="#Regular%20Expressions">Regular Expressions</a>:   Matching regular expressions against strings. 
-<li><a accesskey=4 href="#Word%20Expansion">Word Expansion</a>:        Expanding shell variables, nested commands,
+<li><a accesskey=3 href="#Regular Expressions">Regular Expressions</a>:   Matching regular expressions against strings. 
+<li><a accesskey=4 href="#Word Expansion">Word Expansion</a>:        Expanding shell variables, nested commands,
 			    arithmetic, and wildcards. 
 			    This is what the shell does with shell commands. 
 </ul>
 
 <p><hr>
-Node:<a name="Wildcard%20Matching">Wildcard Matching</a>,
+Node:<a name="Wildcard Matching">Wildcard Matching</a>,
 Next:<a rel=next accesskey=n href="#Globbing">Globbing</a>,
-Up:<a rel=up accesskey=u href="#Pattern%20Matching">Pattern Matching</a>
+Up:<a rel=up accesskey=u href="#Pattern Matching">Pattern Matching</a>
 <br>
 
 <h3>Wildcard Matching</h3>
 
@@ -19810,16 +19380,15 @@
 string fit the pattern or not.  The symbols described here are all
 declared in <code>fnmatch.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fnmatch</b><i> (const char *<var>pattern</var>, const char *<var>string</var>, int <var>flags</var>)
-</i></td>
+<td align="left"><code>int <b>fnmatch</b><i> (const char *<var>pattern</var>, const char *<var>string</var>, int <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function tests whether the string <var>string</var> matches the pattern
 <var>pattern</var>.  It returns <code>0</code> if they do match; otherwise, it
 returns the nonzero value <code>FNM_NOMATCH</code>.  The arguments
@@ -19911,11 +19480,11 @@
 </dl>
 
 <p><hr>
 Node:<a name="Globbing">Globbing</a>,
-Next:<a rel=next accesskey=n href="#Regular%20Expressions">Regular Expressions</a>,
-Previous:<a rel=previous accesskey=p href="#Wildcard%20Matching">Wildcard Matching</a>,
-Up:<a rel=up accesskey=u href="#Pattern%20Matching">Pattern Matching</a>
+Next:<a rel=next accesskey=n href="#Regular Expressions">Regular Expressions</a>,
+Previous:<a rel=previous accesskey=p href="#Wildcard Matching">Wildcard Matching</a>,
+Up:<a rel=up accesskey=u href="#Pattern Matching">Pattern Matching</a>
 <br>
 
 <h3>Globbing</h3>
 
@@ -19932,16 +19501,16 @@
 of wildcards convenient.  <code>glob</code> and the other symbols in this
 section are declared in <code>glob.h</code>.
 
 <ul>
-<li><a accesskey=1 href="#Calling%20Glob">Calling Glob</a>:              Basic use of <code>glob</code>. 
-<li><a accesskey=2 href="#Flags%20for%20Globbing">Flags for Globbing</a>:        Flags that enable various options in <code>glob</code>. 
-<li><a accesskey=3 href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>:   GNU specific extensions to <code>glob</code>. 
+<li><a accesskey=1 href="#Calling Glob">Calling Glob</a>:              Basic use of <code>glob</code>. 
+<li><a accesskey=2 href="#Flags for Globbing">Flags for Globbing</a>:        Flags that enable various options in <code>glob</code>. 
+<li><a accesskey=3 href="#More Flags for Globbing">More Flags for Globbing</a>:   GNU specific extensions to <code>glob</code>. 
 </ul>
 
 <p><hr>
-Node:<a name="Calling%20Glob">Calling Glob</a>,
-Next:<a rel=next accesskey=n href="#Flags%20for%20Globbing">Flags for Globbing</a>,
+Node:<a name="Calling Glob">Calling Glob</a>,
+Next:<a rel=next accesskey=n href="#Flags for Globbing">Flags for Globbing</a>,
 Up:<a rel=up accesskey=u href="#Globbing">Globbing</a>
 <br>
 
 <h4>Calling <code>glob</code></h4>
@@ -19951,16 +19520,15 @@
 is a structure.  You pass <code>glob</code> the address of the structure, and
 it fills in the structure's fields to tell you about the results.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>glob_t</b><i>
-</i></td>
+<td align="left"><code><b>glob_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type holds a pointer to a word vector.  More precisely, it
 records both the address of the word vector and its size.  The GNU
 implementation contains some more fields which are non-standard
@@ -20036,16 +19604,15 @@
 <code>glob_t</code> only in the types of the members <code>gl_readdir</code>,
 <code>gl_stat</code>, and <code>gl_lstat</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>glob64_t</b><i>
-</i></td>
+<td align="left"><code><b>glob64_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type holds a pointer to a word vector.  More precisely, it
 records both the address of the word vector and its size.  The GNU
 implementation contains some more fields which are non-standard
@@ -20116,22 +19683,21 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>glob</b><i> (const char *<var>pattern</var>, int <var>flags</var>, int (*<var>errfunc</var>) (const char *<var>filename</var>, int <var>error-code</var>), glob_t *<var>vector-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>glob</b><i> (const char *<var>pattern</var>, int <var>flags</var>, int (*<var>errfunc</var>) (const char *<var>filename</var>, int <var>error-code</var>), glob_t *<var>vector-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>glob</code> does globbing using the pattern <var>pattern</var>
 in the current directory.  It puts the result in a newly allocated
 vector, and stores the size and address of this vector into
 <code>*<var>vector-ptr</var></code>.  The argument <var>flags</var> is a combination of
-bit flags; see <a href="#Flags%20for%20Globbing">Flags for Globbing</a>, for details of the flags.
+bit flags; see <a href="#Flags for Globbing">Flags for Globbing</a>, for details of the flags.
 
 <p>The result of globbing is a sequence of file names.  The function
 <code>glob</code> allocates a string for each resulting word, then
 allocates a vector of type <code>char **</code> to store the addresses of
@@ -20183,16 +19749,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>glob64</b><i> (const char *<var>pattern</var>, int <var>flags</var>, int (*<var>errfunc</var>) (const char *<var>filename</var>, int <var>error-code</var>), glob64_t *<var>vector-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>glob64</b><i> (const char *<var>pattern</var>, int <var>flags</var>, int (*<var>errfunc</var>) (const char *<var>filename</var>, int <var>error-code</var>), glob64_t *<var>vector-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>glob64</code> function was added as part of the Large File Summit
 extensions but is not part of the original LFS proposal.  The reason for
 this is simple: it is not necessary.  The necessity for a <code>glob64</code>
@@ -20210,11 +19775,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Flags%20for%20Globbing">Flags for Globbing</a>,
-Next:<a rel=next accesskey=n href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>,
-Previous:<a rel=previous accesskey=p href="#Calling%20Glob">Calling Glob</a>,
+Node:<a name="Flags for Globbing">Flags for Globbing</a>,
+Next:<a rel=next accesskey=n href="#More Flags for Globbing">More Flags for Globbing</a>,
+Previous:<a rel=previous accesskey=p href="#Calling Glob">Calling Glob</a>,
 Up:<a rel=up accesskey=u href="#Globbing">Globbing</a>
 <br>
 
 <h4>Flags for Globbing</h4>
@@ -20297,10 +19862,10 @@
 <code>FNM_NOESCAPE</code> flag in calls to <code>fnmatch</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="More%20Flags%20for%20Globbing">More Flags for Globbing</a>,
-Previous:<a rel=previous accesskey=p href="#Flags%20for%20Globbing">Flags for Globbing</a>,
+Node:<a name="More Flags for Globbing">More Flags for Globbing</a>,
+Previous:<a rel=previous accesskey=p href="#Flags for Globbing">Flags for Globbing</a>,
 Up:<a rel=up accesskey=u href="#Globbing">Globbing</a>
 <br>
 
 <h4>More Flags for Globbing</h4>
@@ -20312,9 +19877,9 @@
 
 <dl>
 <dt><code>GLOB_PERIOD</code>
 <dd>The <code>.</code> character (period) is treated special.  It cannot be
-matched by wildcards.  See <a href="#Wildcard%20Matching">Wildcard Matching</a>, <code>FNM_PERIOD</code>.
+matched by wildcards.  See <a href="#Wildcard Matching">Wildcard Matching</a>, <code>FNM_PERIOD</code>.
 
 <br><dt><code>GLOB_MAGCHAR</code>
 <dd>The <code>GLOB_MAGCHAR</code> value is not to be given to <code>glob</code> in the
 <var>flags</var> parameter.  Instead, <code>glob</code> sets this bit in the
@@ -20325,10 +19890,10 @@
 <dd>Instead of the using the using the normal functions for accessing the
 filesystem the <code>glob</code> implementation uses the user-supplied
 functions specified in the structure pointed to by <var>pglob</var>
 parameter.  For more information about the functions refer to the
-sections about directory handling see <a href="#Accessing%20Directories">Accessing Directories</a>, and
-<a href="#Reading%20Attributes">Reading Attributes</a>.
+sections about directory handling see <a href="#Accessing Directories">Accessing Directories</a>, and
+<a href="#Reading Attributes">Reading Attributes</a>.
 
 <br><dt><code>GLOB_BRACE</code>
 <dd>If this flag is given the handling of braces in the pattern is changed. 
 It is now required that braces appear correctly grouped.  I.e., for each
@@ -20425,16 +19990,15 @@
 are freed or reused so that no leaks appear.  But this does not include
 the time when all <code>glob</code> calls are done.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>globfree</b><i> (glob_t *<var>pglob</var>)
-</i></td>
+<td align="left"><code>void <b>globfree</b><i> (glob_t *<var>pglob</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>globfree</code> function frees all resources allocated by previous
 calls to <code>glob</code> associated with the object pointed to by
 <var>pglob</var>.  This function should be called whenever the currently used
@@ -20442,27 +20006,26 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>globfree64</b><i> (glob64_t *<var>pglob</var>)
-</i></td>
+<td align="left"><code>void <b>globfree64</b><i> (glob64_t *<var>pglob</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is equivalent to <code>globfree</code> but it frees records of
 type <code>glob64_t</code> which were allocated by <code>glob64</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Regular%20Expressions">Regular Expressions</a>,
-Next:<a rel=next accesskey=n href="#Word%20Expansion">Word Expansion</a>,
+Node:<a name="Regular Expressions">Regular Expressions</a>,
+Next:<a rel=next accesskey=n href="#Word Expansion">Word Expansion</a>,
 Previous:<a rel=previous accesskey=p href="#Globbing">Globbing</a>,
-Up:<a rel=up accesskey=u href="#Pattern%20Matching">Pattern Matching</a>
+Up:<a rel=up accesskey=u href="#Pattern Matching">Pattern Matching</a>
 <br>
 
 <h3>Regular Expression Matching</h3>
 
@@ -20474,43 +20037,42 @@
 If you define <code>_POSIX_C_SOURCE</code>, then only the POSIX.2
 functions, structures, and constants are declared.
 
 <ul>
-<li><a accesskey=1 href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>:     Using <code>regcomp</code> to prepare to match. 
-<li><a accesskey=2 href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>:      Syntax variations for <code>regcomp</code>. 
-<li><a accesskey=3 href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>:       Using <code>regexec</code> to match the compiled
+<li><a accesskey=1 href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>:     Using <code>regcomp</code> to prepare to match. 
+<li><a accesskey=2 href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>:      Syntax variations for <code>regcomp</code>. 
+<li><a accesskey=3 href="#Matching POSIX Regexps">Matching POSIX Regexps</a>:       Using <code>regexec</code> to match the compiled
 				   pattern that you get from <code>regcomp</code>. 
-<li><a accesskey=4 href="#Regexp%20Subexpressions">Regexp Subexpressions</a>:        Finding which parts of the string were matched. 
-<li><a accesskey=5 href="#Subexpression%20Complications">Subexpression Complications</a>:  Find points of which parts were matched. 
-<li><a accesskey=6 href="#Regexp%20Cleanup">Regexp Cleanup</a>: 		Freeing storage; reporting errors. 
+<li><a accesskey=4 href="#Regexp Subexpressions">Regexp Subexpressions</a>:        Finding which parts of the string were matched. 
+<li><a accesskey=5 href="#Subexpression Complications">Subexpression Complications</a>:  Find points of which parts were matched. 
+<li><a accesskey=6 href="#Regexp Cleanup">Regexp Cleanup</a>: 		Freeing storage; reporting errors. 
 </ul>
 
 <p><hr>
-Node:<a name="POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>,
-Next:<a rel=next accesskey=n href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>,
-Up:<a rel=up accesskey=u href="#Regular%20Expressions">Regular Expressions</a>
+Node:<a name="POSIX Regexp Compilation">POSIX Regexp Compilation</a>,
+Next:<a rel=next accesskey=n href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>,
+Up:<a rel=up accesskey=u href="#Regular Expressions">Regular Expressions</a>
 <br>
 
 <h4>POSIX Regular Expression Compilation</h4>
 
 <p>Before you can actually match a regular expression, you must
 <dfn>compile</dfn> it.  This is not true compilation--it produces a special
 data structure, not machine instructions.  But it is like ordinary
 compilation in that its purpose is to enable you to "execute" the
-pattern fast.  (See <a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>, for how to use the
+pattern fast.  (See <a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>, for how to use the
 compiled regular expression for matching.)
 
 <p>There is a special data type for compiled regular expressions:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>regex_t</b><i>
-</i></td>
+<td align="left"><code><b>regex_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This type of object holds a compiled regular expression. 
 It is actually a structure.  It has just one field that your programs
 should look at:
@@ -20529,16 +20091,15 @@
 <p>After you create a <code>regex_t</code> object, you can compile a regular
 expression into it by calling <code>regcomp</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>regcomp</b><i> (regex_t *<var>compiled</var>, const char *<var>pattern</var>, int <var>cflags</var>)
-</i></td>
+<td align="left"><code>int <b>regcomp</b><i> (regex_t *<var>compiled</var>, const char *<var>pattern</var>, int <var>cflags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>regcomp</code> "compiles" a regular expression into a
 data structure that you can use with <code>regexec</code> to match against a
 string.  The compiled regular expression format is designed for
@@ -20547,9 +20108,9 @@
 <p>It's up to you to allocate an object of type <code>regex_t</code> and pass its
 address to <code>regcomp</code>.
 
 <p>The argument <var>cflags</var> lets you specify various options that control
-the syntax and semantics of regular expressions.  See <a href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>.
+the syntax and semantics of regular expressions.  See <a href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>.
 
 <p>If you use the flag <code>REG_NOSUB</code>, then <code>regcomp</code> omits from
 the compiled regular expression the information necessary to record
 how subexpressions actually match.  In this case, you might as well
@@ -20565,9 +20126,9 @@
 
 <p><code>regcomp</code> returns <code>0</code> if it succeeds in compiling the regular
 expression; otherwise, it returns a nonzero error code (see the table
 below).  You can use <code>regerror</code> to produce an error message string
-describing the reason for a nonzero value; see <a href="#Regexp%20Cleanup">Regexp Cleanup</a>.
+describing the reason for a nonzero value; see <a href="#Regexp Cleanup">Regexp Cleanup</a>.
 
 </td></tr>
 </table>
 
@@ -20588,9 +20149,9 @@
 position (with no preceding subexpression to act on).
 
 <br><dt><code>REG_ECOLLATE</code>
 <dd>The regular expression referred to an invalid collating element (one not
-defined in the current locale for string collation).  See <a href="#Locale%20Categories">Locale Categories</a>.
+defined in the current locale for string collation).  See <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>REG_ECTYPE</code>
 <dd>The regular expression referred to an invalid character class name.
 
@@ -20617,12 +20178,12 @@
 <dd><code>regcomp</code> ran out of memory. 
 </dl>
 
 <p><hr>
-Node:<a name="Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>,
-Next:<a rel=next accesskey=n href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>,
-Previous:<a rel=previous accesskey=p href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>,
-Up:<a rel=up accesskey=u href="#Regular%20Expressions">Regular Expressions</a>
+Node:<a name="Flags for POSIX Regexps">Flags for POSIX Regexps</a>,
+Next:<a rel=next accesskey=n href="#Matching POSIX Regexps">Matching POSIX Regexps</a>,
+Previous:<a rel=previous accesskey=p href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>,
+Up:<a rel=up accesskey=u href="#Regular Expressions">Regular Expressions</a>
 <br>
 
 <h4>Flags for POSIX Regular Expressions</h4>
 
@@ -20649,47 +20210,46 @@
 <p>Otherwise, newline acts like any other ordinary character. 
 </dl>
 
 <p><hr>
-Node:<a name="Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>,
-Next:<a rel=next accesskey=n href="#Regexp%20Subexpressions">Regexp Subexpressions</a>,
-Previous:<a rel=previous accesskey=p href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>,
-Up:<a rel=up accesskey=u href="#Regular%20Expressions">Regular Expressions</a>
+Node:<a name="Matching POSIX Regexps">Matching POSIX Regexps</a>,
+Next:<a rel=next accesskey=n href="#Regexp Subexpressions">Regexp Subexpressions</a>,
+Previous:<a rel=previous accesskey=p href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>,
+Up:<a rel=up accesskey=u href="#Regular Expressions">Regular Expressions</a>
 <br>
 
 <h4>Matching a Compiled POSIX Regular Expression</h4>
 
-<p>Once you have compiled a regular expression, as described in <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>, you can match it against strings using
+<p>Once you have compiled a regular expression, as described in <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>, you can match it against strings using
 <code>regexec</code>.  A match anywhere inside the string counts as success,
 unless the regular expression contains anchor characters (<code>^</code> or
 <code>$</code>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>regexec</b><i> (regex_t *<var>compiled</var>, char *<var>string</var>, size_t <var>nmatch</var>, regmatch_t <var>matchptr</var> <tt>[]</tt>, int <var>eflags</var>)
-</i></td>
+<td align="left"><code>int <b>regexec</b><i> (regex_t *<var>compiled</var>, char *<var>string</var>, size_t <var>nmatch</var>, regmatch_t <var>matchptr</var> <tt>[]</tt>, int <var>eflags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function tries to match the compiled regular expression
 <code>*<var>compiled</var></code> against <var>string</var>.
 
 <p><code>regexec</code> returns <code>0</code> if the regular expression matches;
 otherwise, it returns a nonzero value.  See the table below for
 what nonzero values mean.  You can use <code>regerror</code> to produce an
 error message string describing the reason for a nonzero value;
-see <a href="#Regexp%20Cleanup">Regexp Cleanup</a>.
+see <a href="#Regexp Cleanup">Regexp Cleanup</a>.
 
 <p>The argument <var>eflags</var> is a word of bit flags that enable various
 options.
 
 <p>If you want to get information about what part of <var>string</var> actually
 matched the regular expression or its subexpressions, use the arguments
 <var>matchptr</var> and <var>nmatch</var>.  Otherwise, pass <code>0</code> for
-<var>nmatch</var>, and <code>NULL</code> for <var>matchptr</var>.  See <a href="#Regexp%20Subexpressions">Regexp Subexpressions</a>. 
+<var>nmatch</var>, and <code>NULL</code> for <var>matchptr</var>.  See <a href="#Regexp Subexpressions">Regexp Subexpressions</a>. 
 </td></tr>
 </table>
 
 <p>You must match the regular expression with the same set of current
@@ -20719,12 +20279,12 @@
 <dd><code>regexec</code> ran out of memory. 
 </dl>
 
 <p><hr>
-Node:<a name="Regexp%20Subexpressions">Regexp Subexpressions</a>,
-Next:<a rel=next accesskey=n href="#Subexpression%20Complications">Subexpression Complications</a>,
-Previous:<a rel=previous accesskey=p href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>,
-Up:<a rel=up accesskey=u href="#Regular%20Expressions">Regular Expressions</a>
+Node:<a name="Regexp Subexpressions">Regexp Subexpressions</a>,
+Next:<a rel=next accesskey=n href="#Subexpression Complications">Subexpression Complications</a>,
+Previous:<a rel=previous accesskey=p href="#Matching POSIX Regexps">Matching POSIX Regexps</a>,
+Up:<a rel=up accesskey=u href="#Regular Expressions">Regular Expressions</a>
 <br>
 
 <h4>Match Results with Subexpressions</h4>
 
@@ -20737,16 +20297,15 @@
 the beginning and end of the part that matched a single parenthetical
 subexpression.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>regmatch_t</b><i>
-</i></td>
+<td align="left"><code><b>regmatch_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type of the <var>matcharray</var> array that you pass to
 <code>regexec</code>.  It contains two structure fields, as follows:
 
@@ -20761,16 +20320,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>regoff_t</b><i>
-</i></td>
+<td align="left"><code><b>regoff_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>regoff_t</code> is an alias for another signed integer type. 
 The fields of <code>regmatch_t</code> have type <code>regoff_t</code>. 
 </td></tr>
@@ -20794,12 +20352,12 @@
 <var>nmatch</var>, or use the flag <code>REG_NOSUB</code> when you compile the
 pattern with <code>regcomp</code>.
 
 <p><hr>
-Node:<a name="Subexpression%20Complications">Subexpression Complications</a>,
-Next:<a rel=next accesskey=n href="#Regexp%20Cleanup">Regexp Cleanup</a>,
-Previous:<a rel=previous accesskey=p href="#Regexp%20Subexpressions">Regexp Subexpressions</a>,
-Up:<a rel=up accesskey=u href="#Regular%20Expressions">Regular Expressions</a>
+Node:<a name="Subexpression Complications">Subexpression Complications</a>,
+Next:<a rel=next accesskey=n href="#Regexp Cleanup">Regexp Cleanup</a>,
+Previous:<a rel=previous accesskey=p href="#Regexp Subexpressions">Regexp Subexpressions</a>,
+Up:<a rel=up accesskey=u href="#Regular Expressions">Regular Expressions</a>
 <br>
 
 <h4>Complications in Subexpression Matching</h4>
 
@@ -20845,27 +20403,26 @@
 repetition, the "na" subexpression is not used.  So <code>regexec</code>
 reports nonuse of the "na" subexpression.
 
 <p><hr>
-Node:<a name="Regexp%20Cleanup">Regexp Cleanup</a>,
-Previous:<a rel=previous accesskey=p href="#Subexpression%20Complications">Subexpression Complications</a>,
-Up:<a rel=up accesskey=u href="#Regular%20Expressions">Regular Expressions</a>
+Node:<a name="Regexp Cleanup">Regexp Cleanup</a>,
+Previous:<a rel=previous accesskey=p href="#Subexpression Complications">Subexpression Complications</a>,
+Up:<a rel=up accesskey=u href="#Regular Expressions">Regular Expressions</a>
 <br>
 
 <h4>POSIX Regexp Matching Cleanup</h4>
 
 <p>When you are finished using a compiled regular expression, you can
 free the storage it uses by calling <code>regfree</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>regfree</b><i> (regex_t *<var>compiled</var>)
-</i></td>
+<td align="left"><code>void <b>regfree</b><i> (regex_t *<var>compiled</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Calling <code>regfree</code> frees all the storage that <code>*<var>compiled</var></code>
 points to.  This includes various internal fields of the <code>regex_t</code>
 structure that aren't documented in this manual.
@@ -20881,16 +20438,15 @@
 <p>When <code>regcomp</code> or <code>regexec</code> reports an error, you can use
 the function <code>regerror</code> to turn it into an error message string.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>regerror</b><i> (int <var>errcode</var>, regex_t *<var>compiled</var>, char *<var>buffer</var>, size_t <var>length</var>)
-</i></td>
+<td align="left"><code>size_t <b>regerror</b><i> (int <var>errcode</var>, regex_t *<var>compiled</var>, char *<var>buffer</var>, size_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function produces an error message string for the error code
 <var>errcode</var>, and stores the string in <var>length</var> bytes of memory
 starting at <var>buffer</var>.  For the <var>compiled</var> argument, supply the
@@ -20923,11 +20479,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Word%20Expansion">Word Expansion</a>,
-Previous:<a rel=previous accesskey=p href="#Regular%20Expressions">Regular Expressions</a>,
-Up:<a rel=up accesskey=u href="#Pattern%20Matching">Pattern Matching</a>
+Node:<a name="Word Expansion">Word Expansion</a>,
+Previous:<a rel=previous accesskey=p href="#Regular Expressions">Regular Expressions</a>,
+Up:<a rel=up accesskey=u href="#Pattern Matching">Pattern Matching</a>
 <br>
 
 <h3>Shell-Style Word Expansion</h3>
 
@@ -20951,20 +20507,20 @@
 <p>Ordinary programs can perform word expansion just like the shell by
 calling the library function <code>wordexp</code>.
 
 <ul>
-<li><a accesskey=1 href="#Expansion%20Stages">Expansion Stages</a>:             What word expansion does to a string. 
-<li><a accesskey=2 href="#Calling%20Wordexp">Calling Wordexp</a>:              How to call <code>wordexp</code>. 
-<li><a accesskey=3 href="#Flags%20for%20Wordexp">Flags for Wordexp</a>:            Options you can enable in <code>wordexp</code>. 
-<li><a accesskey=4 href="#Wordexp%20Example">Wordexp Example</a>:              A sample program that does word expansion. 
-<li><a accesskey=5 href="#Tilde%20Expansion">Tilde Expansion</a>:              Details of how tilde expansion works. 
-<li><a accesskey=6 href="#Variable%20Substitution">Variable Substitution</a>:        Different types of variable substitution. 
+<li><a accesskey=1 href="#Expansion Stages">Expansion Stages</a>:             What word expansion does to a string. 
+<li><a accesskey=2 href="#Calling Wordexp">Calling Wordexp</a>:              How to call <code>wordexp</code>. 
+<li><a accesskey=3 href="#Flags for Wordexp">Flags for Wordexp</a>:            Options you can enable in <code>wordexp</code>. 
+<li><a accesskey=4 href="#Wordexp Example">Wordexp Example</a>:              A sample program that does word expansion. 
+<li><a accesskey=5 href="#Tilde Expansion">Tilde Expansion</a>:              Details of how tilde expansion works. 
+<li><a accesskey=6 href="#Variable Substitution">Variable Substitution</a>:        Different types of variable substitution. 
 </ul>
 
 <p><hr>
-Node:<a name="Expansion%20Stages">Expansion Stages</a>,
-Next:<a rel=next accesskey=n href="#Calling%20Wordexp">Calling Wordexp</a>,
-Up:<a rel=up accesskey=u href="#Word%20Expansion">Word Expansion</a>
+Node:<a name="Expansion Stages">Expansion Stages</a>,
+Next:<a rel=next accesskey=n href="#Calling Wordexp">Calling Wordexp</a>,
+Up:<a rel=up accesskey=u href="#Word Expansion">Word Expansion</a>
 <br>
 
 <h4>The Stages of Word Expansion</h4>
 
@@ -20981,9 +20537,9 @@
 <ul>
 <li><dfn>Variable substitution</dfn>: Environment variables are substituted for
 references such as <code>$foo</code>.
 
-<li><dfn>Command substitution</dfn>: Constructs such as <code>`cat&nbsp;foo`</code> and
+<li><dfn>Command substitution</dfn>: Constructs such as <code>'cat&nbsp;foo'</code> and
 the equivalent <code>$(cat&nbsp;foo)</code> are replaced with the output from
 the inner command.
 
 <li><dfn>Arithmetic expansion</dfn>: Constructs such as <code>$(($x-1))</code> are
@@ -21004,12 +20560,12 @@
 <p>For the details of these transformations, and how to write the constructs
 that use them, see <cite>The&nbsp;BASH&nbsp;Manual</cite> (to appear).
 
 <p><hr>
-Node:<a name="Calling%20Wordexp">Calling Wordexp</a>,
-Next:<a rel=next accesskey=n href="#Flags%20for%20Wordexp">Flags for Wordexp</a>,
-Previous:<a rel=previous accesskey=p href="#Expansion%20Stages">Expansion Stages</a>,
-Up:<a rel=up accesskey=u href="#Word%20Expansion">Word Expansion</a>
+Node:<a name="Calling Wordexp">Calling Wordexp</a>,
+Next:<a rel=next accesskey=n href="#Flags for Wordexp">Flags for Wordexp</a>,
+Previous:<a rel=previous accesskey=p href="#Expansion Stages">Expansion Stages</a>,
+Up:<a rel=up accesskey=u href="#Word Expansion">Word Expansion</a>
 <br>
 
 <h4>Calling <code>wordexp</code></h4>
 
@@ -21021,16 +20577,15 @@
 is a structure.  You pass <code>wordexp</code> the address of the structure,
 and it fills in the structure's fields to tell you about the results.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>wordexp_t</b><i>
-</i></td>
+<td align="left"><code><b>wordexp_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type holds a pointer to a word vector.  More precisely, it
 records both the address of the word vector and its size.
 
@@ -21058,28 +20613,27 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wordexp</b><i> (const char *<var>words</var>, wordexp_t *<var>word-vector-ptr</var>, int <var>flags</var>)
-</i></td>
+<td align="left"><code>int <b>wordexp</b><i> (const char *<var>words</var>, wordexp_t *<var>word-vector-ptr</var>, int <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Perform word expansion on the string <var>words</var>, putting the result in
 a newly allocated vector, and store the size and address of this vector
 into <code>*<var>word-vector-ptr</var></code>.  The argument <var>flags</var> is a
-combination of bit flags; see <a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>, for details of
+combination of bit flags; see <a href="#Flags for Wordexp">Flags for Wordexp</a>, for details of
 the flags.
 
 <p>You shouldn't use any of the characters <code>|&amp;;&lt;&gt;</code> in the string
 <var>words</var> unless they are quoted; likewise for newline.  If you use
 these characters unquoted, you will get the <code>WRDE_BADCHAR</code> error
 code.  Don't use parentheses or braces unless they are quoted or part of
-a word expansion construct.  If you use quotation characters <code>'"`</code>,
+a word expansion construct.  If you use quotation characters <code>'"'</code>,
 they should come in pairs that balance.
 
 <p>The results of word expansion are a sequence of words.  The function
 <code>wordexp</code> allocates a string for each resulting word, then
@@ -21119,16 +20673,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>wordfree</b><i> (wordexp_t *<var>word-vector-ptr</var>)
-</i></td>
+<td align="left"><code>void <b>wordfree</b><i> (wordexp_t *<var>word-vector-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Free the storage used for the word-strings and vector that
 <code>*<var>word-vector-ptr</var></code> points to.  This does not free the
 structure <code>*<var>word-vector-ptr</var></code> itself--only the other
@@ -21136,12 +20689,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Flags%20for%20Wordexp">Flags for Wordexp</a>,
-Next:<a rel=next accesskey=n href="#Wordexp%20Example">Wordexp Example</a>,
-Previous:<a rel=previous accesskey=p href="#Calling%20Wordexp">Calling Wordexp</a>,
-Up:<a rel=up accesskey=u href="#Word%20Expansion">Word Expansion</a>
+Node:<a name="Flags for Wordexp">Flags for Wordexp</a>,
+Next:<a rel=next accesskey=n href="#Wordexp Example">Wordexp Example</a>,
+Previous:<a rel=previous accesskey=p href="#Calling Wordexp">Calling Wordexp</a>,
+Up:<a rel=up accesskey=u href="#Word Expansion">Word Expansion</a>
 <br>
 
 <h4>Flags for Word Expansion</h4>
 
@@ -21189,12 +20742,12 @@
 error. 
 </dl>
 
 <p><hr>
-Node:<a name="Wordexp%20Example">Wordexp Example</a>,
-Next:<a rel=next accesskey=n href="#Tilde%20Expansion">Tilde Expansion</a>,
-Previous:<a rel=previous accesskey=p href="#Flags%20for%20Wordexp">Flags for Wordexp</a>,
-Up:<a rel=up accesskey=u href="#Word%20Expansion">Word Expansion</a>
+Node:<a name="Wordexp Example">Wordexp Example</a>,
+Next:<a rel=next accesskey=n href="#Tilde Expansion">Tilde Expansion</a>,
+Previous:<a rel=previous accesskey=p href="#Flags for Wordexp">Flags for Wordexp</a>,
+Up:<a rel=up accesskey=u href="#Word Expansion">Word Expansion</a>
 <br>
 
 <h4><code>wordexp</code> Example</h4>
 
@@ -21253,12 +20806,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Tilde%20Expansion">Tilde Expansion</a>,
-Next:<a rel=next accesskey=n href="#Variable%20Substitution">Variable Substitution</a>,
-Previous:<a rel=previous accesskey=p href="#Wordexp%20Example">Wordexp Example</a>,
-Up:<a rel=up accesskey=u href="#Word%20Expansion">Word Expansion</a>
+Node:<a name="Tilde Expansion">Tilde Expansion</a>,
+Next:<a rel=next accesskey=n href="#Variable Substitution">Variable Substitution</a>,
+Previous:<a rel=previous accesskey=p href="#Wordexp Example">Wordexp Example</a>,
+Up:<a rel=up accesskey=u href="#Word Expansion">Word Expansion</a>
 <br>
 
 <h4>Details of Tilde Expansion</h4>
 
@@ -21281,11 +20834,11 @@
 by your own name can give different results from plain <code>~</code>, if
 the value of <code>HOME</code> is not really your home directory.
 
 <p><hr>
-Node:<a name="Variable%20Substitution">Variable Substitution</a>,
-Previous:<a rel=previous accesskey=p href="#Tilde%20Expansion">Tilde Expansion</a>,
-Up:<a rel=up accesskey=u href="#Word%20Expansion">Word Expansion</a>
+Node:<a name="Variable Substitution">Variable Substitution</a>,
+Previous:<a rel=previous accesskey=p href="#Tilde Expansion">Tilde Expansion</a>,
+Up:<a rel=up accesskey=u href="#Word Expansion">Word Expansion</a>
 <br>
 
 <h4>Details of Variable Substitution</h4>
 
@@ -21393,11 +20946,11 @@
 
 </dl>
 
 <p><hr>
-Node:<a name="I%2fO%20Overview">I/O Overview</a>,
-Next:<a rel=next accesskey=n href="#I%2fO%20on%20Streams">I/O on Streams</a>,
-Previous:<a rel=previous accesskey=p href="#Pattern%20Matching">Pattern Matching</a>,
+Node:<a name="I%2fO Overview">I/O Overview</a>,
+Next:<a rel=next accesskey=n href="#I%2fO on Streams">I/O on Streams</a>,
+Previous:<a rel=previous accesskey=p href="#Pattern Matching">Pattern Matching</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Input/Output Overview</h2>
@@ -21411,37 +20964,37 @@
 <p>This chapter introduces concepts and terminology relating to input
 and output.  Other chapters relating to the GNU I/O facilities are:
 
 <ul>
-<li><a href="#I%2fO%20on%20Streams">I/O on Streams</a>, which covers the high-level functions
+<li><a href="#I%2fO on Streams">I/O on Streams</a>, which covers the high-level functions
 that operate on streams, including formatted input and output.
 
-<li><a href="#Low-Level%20I%2fO">Low-Level I/O</a>, which covers the basic I/O and control
+<li><a href="#Low-Level I%2fO">Low-Level I/O</a>, which covers the basic I/O and control
 functions on file descriptors.
 
-<li><a href="#File%20System%20Interface">File System Interface</a>, which covers functions for operating on
+<li><a href="#File System Interface">File System Interface</a>, which covers functions for operating on
 directories and for manipulating file attributes such as access modes
 and ownership.
 
-<li><a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>, which includes information on the basic interprocess
+<li><a href="#Pipes and FIFOs">Pipes and FIFOs</a>, which includes information on the basic interprocess
 communication facilities.
 
 <li><a href="#Sockets">Sockets</a>, which covers a more complicated interprocess communication
 facility with support for networking.
 
-<li><a href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>, which covers functions for changing
+<li><a href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>, which covers functions for changing
 how input and output to terminals or other serial devices are processed. 
 </ul>
 
 <ul>
-<li><a accesskey=1 href="#I%2fO%20Concepts">I/O Concepts</a>:        Some basic information and terminology. 
-<li><a accesskey=2 href="#File%20Names">File Names</a>:          How to refer to a file. 
+<li><a accesskey=1 href="#I%2fO Concepts">I/O Concepts</a>:        Some basic information and terminology. 
+<li><a accesskey=2 href="#File Names">File Names</a>:          How to refer to a file. 
 </ul>
 
 <p><hr>
-Node:<a name="I%2fO%20Concepts">I/O Concepts</a>,
-Next:<a rel=next accesskey=n href="#File%20Names">File Names</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20Overview">I/O Overview</a>
+Node:<a name="I%2fO Concepts">I/O Concepts</a>,
+Next:<a rel=next accesskey=n href="#File Names">File Names</a>,
+Up:<a rel=up accesskey=u href="#I%2fO Overview">I/O Overview</a>
 <br>
 
 <h3>Input/Output Concepts</h3>
 
@@ -21461,18 +21014,18 @@
 closed a stream or file descriptor, you cannot do any more input or
 output operations on it.
 
 <ul>
-<li><a accesskey=1 href="#Streams%20and%20File%20Descriptors">Streams and File Descriptors</a>:     The GNU Library provides two ways
+<li><a accesskey=1 href="#Streams and File Descriptors">Streams and File Descriptors</a>:     The GNU Library provides two ways
 			             to access the contents of files. 
-<li><a accesskey=2 href="#File%20Position">File Position</a>:                    The number of bytes from the
+<li><a accesskey=2 href="#File Position">File Position</a>:                    The number of bytes from the
                                      beginning of the file. 
 </ul>
 
 <p><hr>
-Node:<a name="Streams%20and%20File%20Descriptors">Streams and File Descriptors</a>,
-Next:<a rel=next accesskey=n href="#File%20Position">File Position</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20Concepts">I/O Concepts</a>
+Node:<a name="Streams and File Descriptors">Streams and File Descriptors</a>,
+Next:<a rel=next accesskey=n href="#File Position">File Position</a>,
+Up:<a rel=up accesskey=u href="#I%2fO Concepts">I/O Concepts</a>
 <br>
 
 <h4>Streams and File Descriptors</h4>
 
@@ -21489,14 +21042,14 @@
 you want to do control operations that are specific to a particular kind
 of device, you must use a file descriptor; there are no facilities to
 use streams in this way.  You must also use file descriptors if your
 program needs to do input or output in special modes, such as
-nonblocking (or polled) input (see <a href="#File%20Status%20Flags">File Status Flags</a>).
+nonblocking (or polled) input (see <a href="#File Status Flags">File Status Flags</a>).
 
 <p>Streams provide a higher-level interface, layered on top of the
 primitive file descriptor facilities.  The stream interface treats all
 kinds of files pretty much alike--the sole exception being the three
-styles of buffering that you can choose (see <a href="#Stream%20Buffering">Stream Buffering</a>).
+styles of buffering that you can choose (see <a href="#Stream Buffering">Stream Buffering</a>).
 
 <p>The main advantage of using the stream interface is that the set of
 functions for performing actual input and output operations (as opposed
 to control operations) on streams is much richer and more powerful than
@@ -21515,10 +21068,10 @@
 <p>In general, you should stick with using streams rather than file
 descriptors, unless there is some specific operation you want to do that
 can only be done on a file descriptor.  If you are a beginning
 programmer and aren't sure what functions to use, we suggest that you
-concentrate on the formatted input functions (see <a href="#Formatted%20Input">Formatted Input</a>)
-and formatted output functions (see <a href="#Formatted%20Output">Formatted Output</a>).
+concentrate on the formatted input functions (see <a href="#Formatted Input">Formatted Input</a>)
+and formatted output functions (see <a href="#Formatted Output">Formatted Output</a>).
 
 <p>If you are concerned about portability of your programs to systems other
 than GNU, you should also be aware that file descriptors are not as
 portable as streams.  You can expect any system running ISO&nbsp;C to
@@ -21527,11 +21080,11 @@
 file descriptors.  Most of the file descriptor functions in the GNU
 library are included in the POSIX.1 standard, however.
 
 <p><hr>
-Node:<a name="File%20Position">File Position</a>,
-Previous:<a rel=previous accesskey=p href="#Streams%20and%20File%20Descriptors">Streams and File Descriptors</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20Concepts">I/O Concepts</a>
+Node:<a name="File Position">File Position</a>,
+Previous:<a rel=previous accesskey=p href="#Streams and File Descriptors">Streams and File Descriptors</a>,
+Up:<a rel=up accesskey=u href="#I%2fO Concepts">I/O Concepts</a>
 <br>
 
 <h4>File Position</h4>
 
@@ -21549,10 +21102,10 @@
 <p>Ordinary files permit read or write operations at any position within
 the file.  Some other kinds of files may also permit this.  Files which
 do permit this are sometimes referred to as <dfn>random-access</dfn> files. 
 You can change the file position using the <code>fseek</code> function on a
-stream (see <a href="#File%20Positioning">File Positioning</a>) or the <code>lseek</code> function on a file
-descriptor (see <a href="#I%2fO%20Primitives">I/O Primitives</a>).  If you try to change the file
+stream (see <a href="#File Positioning">File Positioning</a>) or the <code>lseek</code> function on a file
+descriptor (see <a href="#I%2fO Primitives">I/O Primitives</a>).  If you try to change the file
 position on a file that doesn't support random access, you get the
 <code>ESPIPE</code> error.
 
 <p>Streams and descriptors that are opened for <dfn>append access</dfn> are
@@ -21574,11 +21127,11 @@
 another descriptor, these two descriptors share the same file position:
 changing the file position of one descriptor will affect the other.
 
 <p><hr>
-Node:<a name="File%20Names">File Names</a>,
-Previous:<a rel=previous accesskey=p href="#I%2fO%20Concepts">I/O Concepts</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20Overview">I/O Overview</a>
+Node:<a name="File Names">File Names</a>,
+Previous:<a rel=previous accesskey=p href="#I%2fO Concepts">I/O Concepts</a>,
+Up:<a rel=up accesskey=u href="#I%2fO Overview">I/O Overview</a>
 <br>
 
 <h3>File Names</h3>
 
@@ -21593,17 +21146,17 @@
 operating system works with them.
 
 <ul>
 <li><a accesskey=1 href="#Directories">Directories</a>:                  Directories contain entries for files. 
-<li><a accesskey=2 href="#File%20Name%20Resolution">File Name Resolution</a>:         A file name specifies how to look up a file. 
-<li><a accesskey=3 href="#File%20Name%20Errors">File Name Errors</a>:             Error conditions relating to file names. 
-<li><a accesskey=4 href="#File%20Name%20Portability">File Name Portability</a>:        File name portability and syntax issues. 
+<li><a accesskey=2 href="#File Name Resolution">File Name Resolution</a>:         A file name specifies how to look up a file. 
+<li><a accesskey=3 href="#File Name Errors">File Name Errors</a>:             Error conditions relating to file names. 
+<li><a accesskey=4 href="#File Name Portability">File Name Portability</a>:        File name portability and syntax issues. 
 </ul>
 
 <p><hr>
 Node:<a name="Directories">Directories</a>,
-Next:<a rel=next accesskey=n href="#File%20Name%20Resolution">File Name Resolution</a>,
-Up:<a rel=up accesskey=u href="#File%20Names">File Names</a>
+Next:<a rel=next accesskey=n href="#File Name Resolution">File Name Resolution</a>,
+Up:<a rel=up accesskey=u href="#File Names">File Names</a>
 <br>
 
 <h4>Directories</h4>
 
@@ -21635,15 +21188,15 @@
 <code>PATH_MAX</code>.  These macros are defined by the POSIX standard, so we
 cannot change their names.
 
 <p>You can find more detailed information about operations on directories
-in <a href="#File%20System%20Interface">File System Interface</a>.
+in <a href="#File System Interface">File System Interface</a>.
 
 <p><hr>
-Node:<a name="File%20Name%20Resolution">File Name Resolution</a>,
-Next:<a rel=next accesskey=n href="#File%20Name%20Errors">File Name Errors</a>,
+Node:<a name="File Name Resolution">File Name Resolution</a>,
+Next:<a rel=next accesskey=n href="#File Name Errors">File Name Errors</a>,
 Previous:<a rel=previous accesskey=p href="#Directories">Directories</a>,
-Up:<a rel=up accesskey=u href="#File%20Names">File Names</a>
+Up:<a rel=up accesskey=u href="#File Names">File Names</a>
 <br>
 
 <h4>File Name Resolution</h4>
 
@@ -21666,9 +21219,9 @@
 processes on the system have the same root directory).  Such a file name
 is called an <dfn>absolute file name</dfn>.
 
 <p>Otherwise, the first component in the file name is located in the
-current working directory (see <a href="#Working%20Directory">Working Directory</a>).  This kind of
+current working directory (see <a href="#Working Directory">Working Directory</a>).  This kind of
 file name is called a <dfn>relative file name</dfn>.
 
 <p>The file name components <code>.</code> ("dot") and <code>..</code> ("dot-dot")
 have special meanings.  Every directory has entries for these file name
@@ -21715,12 +21268,12 @@
 have names suffixed with <code>.c</code>--but there is nothing in the file
 system itself that enforces this kind of convention.
 
 <p><hr>
-Node:<a name="File%20Name%20Errors">File Name Errors</a>,
-Next:<a rel=next accesskey=n href="#File%20Name%20Portability">File Name Portability</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Name%20Resolution">File Name Resolution</a>,
-Up:<a rel=up accesskey=u href="#File%20Names">File Names</a>
+Node:<a name="File Name Errors">File Name Errors</a>,
+Next:<a rel=next accesskey=n href="#File Name Portability">File Name Portability</a>,
+Previous:<a rel=previous accesskey=p href="#File Name Resolution">File Name Resolution</a>,
+Up:<a rel=up accesskey=u href="#File Names">File Names</a>
 <br>
 
 <h4>File Name Errors</h4>
 
@@ -21736,18 +21289,18 @@
 
 <br><dt><code>ENAMETOOLONG</code>
 <dd>This error is used when either the total length of a file name is
 greater than <code>PATH_MAX</code>, or when an individual file name component
-has a length greater than <code>NAME_MAX</code>.  See <a href="#Limits%20for%20Files">Limits for Files</a>.
+has a length greater than <code>NAME_MAX</code>.  See <a href="#Limits for Files">Limits for Files</a>.
 
 <p>In the GNU system, there is no imposed limit on overall file name
 length, but some file systems may place limits on the length of a
 component.
 
 <br><dt><code>ENOENT</code>
 <dd>This error is reported when a file referenced as a directory component
 in the file name doesn't exist, or when a component is a symbolic link
-whose target file does not exist.  See <a href="#Symbolic%20Links">Symbolic Links</a>.
+whose target file does not exist.  See <a href="#Symbolic Links">Symbolic Links</a>.
 
 <br><dt><code>ENOTDIR</code>
 <dd>A file that is referenced as a directory component in the file name
 exists, but it isn't a directory.
@@ -21755,20 +21308,20 @@
 <br><dt><code>ELOOP</code>
 <dd>Too many symbolic links were resolved while trying to look up the file
 name.  The system has an arbitrary limit on the number of symbolic links
 that may be resolved in looking up a single file name, as a primitive
-way to detect loops.  See <a href="#Symbolic%20Links">Symbolic Links</a>. 
+way to detect loops.  See <a href="#Symbolic Links">Symbolic Links</a>. 
 </dl>
 
 <p><hr>
-Node:<a name="File%20Name%20Portability">File Name Portability</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Name%20Errors">File Name Errors</a>,
-Up:<a rel=up accesskey=u href="#File%20Names">File Names</a>
+Node:<a name="File Name Portability">File Name Portability</a>,
+Previous:<a rel=previous accesskey=p href="#File Name Errors">File Name Errors</a>,
+Up:<a rel=up accesskey=u href="#File Names">File Names</a>
 <br>
 
 <h4>Portability of File Names</h4>
 
-<p>The rules for the syntax of file names discussed in <a href="#File%20Names">File Names</a>,
+<p>The rules for the syntax of file names discussed in <a href="#File Names">File Names</a>,
 are the rules normally used by the GNU system and by other POSIX
 systems.  However, other operating systems may use other conventions.
 
 <p>There are two reasons why it can be important for you to be aware of
@@ -21803,53 +21356,53 @@
 permitted in a file name string, and there are no limits on the length
 of file name strings.
 
 <p><hr>
-Node:<a name="I%2fO%20on%20Streams">I/O on Streams</a>,
-Next:<a rel=next accesskey=n href="#Low-Level%20I%2fO">Low-Level I/O</a>,
-Previous:<a rel=previous accesskey=p href="#I%2fO%20Overview">I/O Overview</a>,
+Node:<a name="I%2fO on Streams">I/O on Streams</a>,
+Next:<a rel=next accesskey=n href="#Low-Level I%2fO">Low-Level I/O</a>,
+Previous:<a rel=previous accesskey=p href="#I%2fO Overview">I/O Overview</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Input/Output on Streams</h2>
 
 <p>This chapter describes the functions for creating streams and performing
-input and output operations on them.  As discussed in <a href="#I%2fO%20Overview">I/O Overview</a>, a stream is a fairly abstract, high-level concept
+input and output operations on them.  As discussed in <a href="#I%2fO Overview">I/O Overview</a>, a stream is a fairly abstract, high-level concept
 representing a communications channel to a file, device, or process.
 
 <ul>
 <li><a accesskey=1 href="#Streams">Streams</a>:                      About the data type representing a stream. 
-<li><a accesskey=2 href="#Standard%20Streams">Standard Streams</a>:             Streams to the standard input and output
+<li><a accesskey=2 href="#Standard Streams">Standard Streams</a>:             Streams to the standard input and output
                                  devices are created for you. 
-<li><a accesskey=3 href="#Opening%20Streams">Opening Streams</a>:              How to create a stream to talk to a file. 
-<li><a accesskey=4 href="#Closing%20Streams">Closing Streams</a>:              Close a stream when you are finished with it. 
-<li><a accesskey=5 href="#Streams%20and%20Threads">Streams and Threads</a>:          Issues with streams in threaded programs. 
-<li><a accesskey=6 href="#Streams%20and%20I18N">Streams and I18N</a>:             Streams in internationalized applications. 
-<li><a accesskey=7 href="#Simple%20Output">Simple Output</a>:                Unformatted output by characters and lines. 
-<li><a accesskey=8 href="#Character%20Input">Character Input</a>:              Unformatted input by characters and words. 
-<li><a accesskey=9 href="#Line%20Input">Line Input</a>:                   Reading a line or a record from a stream. 
+<li><a accesskey=3 href="#Opening Streams">Opening Streams</a>:              How to create a stream to talk to a file. 
+<li><a accesskey=4 href="#Closing Streams">Closing Streams</a>:              Close a stream when you are finished with it. 
+<li><a accesskey=5 href="#Streams and Threads">Streams and Threads</a>:          Issues with streams in threaded programs. 
+<li><a accesskey=6 href="#Streams and I18N">Streams and I18N</a>:             Streams in internationalized applications. 
+<li><a accesskey=7 href="#Simple Output">Simple Output</a>:                Unformatted output by characters and lines. 
+<li><a accesskey=8 href="#Character Input">Character Input</a>:              Unformatted input by characters and words. 
+<li><a accesskey=9 href="#Line Input">Line Input</a>:                   Reading a line or a record from a stream. 
 <li><a href="#Unreading">Unreading</a>:                    Peeking ahead/pushing back input just read. 
-<li><a href="#Block%20Input%2fOutput">Block Input/Output</a>:           Input and output operations on blocks of data. 
-<li><a href="#Formatted%20Output">Formatted Output</a>:             <code>printf</code> and related functions. 
-<li><a href="#Customizing%20Printf">Customizing Printf</a>:           You can define new conversion specifiers for
+<li><a href="#Block Input%2fOutput">Block Input/Output</a>:           Input and output operations on blocks of data. 
+<li><a href="#Formatted Output">Formatted Output</a>:             <code>printf</code> and related functions. 
+<li><a href="#Customizing Printf">Customizing Printf</a>:           You can define new conversion specifiers for
                                  <code>printf</code> and friends. 
-<li><a href="#Formatted%20Input">Formatted Input</a>:              <code>scanf</code> and related functions. 
-<li><a href="#EOF%20and%20Errors">EOF and Errors</a>:               How you can tell if an I/O error happens. 
-<li><a href="#Error%20Recovery">Error Recovery</a>: 		What you can do about errors. 
-<li><a href="#Binary%20Streams">Binary Streams</a>:               Some systems distinguish between text files
+<li><a href="#Formatted Input">Formatted Input</a>:              <code>scanf</code> and related functions. 
+<li><a href="#EOF and Errors">EOF and Errors</a>:               How you can tell if an I/O error happens. 
+<li><a href="#Error Recovery">Error Recovery</a>: 		What you can do about errors. 
+<li><a href="#Binary Streams">Binary Streams</a>:               Some systems distinguish between text files
                                  and binary files. 
-<li><a href="#File%20Positioning">File Positioning</a>:             About random-access streams. 
-<li><a href="#Portable%20Positioning">Portable Positioning</a>:         Random access on peculiar ISO C systems. 
-<li><a href="#Stream%20Buffering">Stream Buffering</a>:             How to control buffering of streams. 
-<li><a href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>:       Streams that do not necessarily correspond
+<li><a href="#File Positioning">File Positioning</a>:             About random-access streams. 
+<li><a href="#Portable Positioning">Portable Positioning</a>:         Random access on peculiar ISO C systems. 
+<li><a href="#Stream Buffering">Stream Buffering</a>:             How to control buffering of streams. 
+<li><a href="#Other Kinds of Streams">Other Kinds of Streams</a>:       Streams that do not necessarily correspond
                                  to an open file. 
-<li><a href="#Formatted%20Messages">Formatted Messages</a>:           Print strictly formatted messages. 
+<li><a href="#Formatted Messages">Formatted Messages</a>:           Print strictly formatted messages. 
 </ul>
 
 <p><hr>
 Node:<a name="Streams">Streams</a>,
-Next:<a rel=next accesskey=n href="#Standard%20Streams">Standard Streams</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Next:<a rel=next accesskey=n href="#Standard Streams">Standard Streams</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Streams</h3>
 
@@ -21863,23 +21416,22 @@
 
 <p>The <code>FILE</code> type is declared in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>FILE</b><i>
-</i></td>
+<td align="left"><code><b>FILE</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type used to represent stream objects.  A <code>FILE</code>
 object holds all of the internal state information about the connection
 to the associated file, including such things as the file position
 indicator and buffering information.  Each stream also has error and
 end-of-file status indicators that can be tested with the <code>ferror</code>
-and <code>feof</code> functions; see <a href="#EOF%20and%20Errors">EOF and Errors</a>. 
+and <code>feof</code> functions; see <a href="#EOF and Errors">EOF and Errors</a>. 
 </td></tr>
 </table>
 
 <p><code>FILE</code> objects are allocated and managed internally by the
@@ -21888,12 +21440,12 @@
 deal only with pointers to these objects (that is, <code>FILE *</code> values)
 rather than the objects themselves.
 
 <p><hr>
-Node:<a name="Standard%20Streams">Standard Streams</a>,
-Next:<a rel=next accesskey=n href="#Opening%20Streams">Opening Streams</a>,
+Node:<a name="Standard Streams">Standard Streams</a>,
+Next:<a rel=next accesskey=n href="#Opening Streams">Opening Streams</a>,
 Previous:<a rel=previous accesskey=p href="#Streams">Streams</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Standard Streams</h3>
 
@@ -21904,46 +21456,43 @@
 
 <p>These streams are declared in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>stdin</b><i>
-</i></td>
+<td align="left"><code>FILE * <b>stdin</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <dfn>standard input</dfn> stream, which is the normal source of input for the
 program. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>stdout</b><i>
-</i></td>
+<td align="left"><code>FILE * <b>stdout</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <dfn>standard output</dfn> stream, which is used for normal output from
 the program. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>stderr</b><i>
-</i></td>
+<td align="left"><code>FILE * <b>stderr</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <dfn>standard error</dfn> stream, which is used for error messages and
 diagnostics issued by the program. 
 </td></tr>
@@ -21951,9 +21500,9 @@
 
 <p>In the GNU system, you can specify what files or processes correspond to
 these streams using the pipe and redirection facilities provided by the
 shell.  (The primitives shells use to implement these facilities are
-described in <a href="#File%20System%20Interface">File System Interface</a>.)  Most other operating systems
+described in <a href="#File System Interface">File System Interface</a>.)  Most other operating systems
 provide similar mechanisms, but the details of how to use them can vary.
 
 <p>In the GNU C library, <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are
 normal variables which you can set just like any others.  For example,
@@ -21965,18 +21514,18 @@
 
 <p>Note however, that in other systems <code>stdin</code>, <code>stdout</code>, and
 <code>stderr</code> are macros that you cannot assign to in the normal way. 
 But you can use <code>freopen</code> to get the effect of closing one and
-reopening it.  See <a href="#Opening%20Streams">Opening Streams</a>.
+reopening it.  See <a href="#Opening Streams">Opening Streams</a>.
 
 <p>The three streams <code>stdin</code>, <code>stdout</code>, and <code>stderr</code> are not
-unoriented at program start (see <a href="#Streams%20and%20I18N">Streams and I18N</a>).
+unoriented at program start (see <a href="#Streams and I18N">Streams and I18N</a>).
 
 <p><hr>
-Node:<a name="Opening%20Streams">Opening Streams</a>,
-Next:<a rel=next accesskey=n href="#Closing%20Streams">Closing Streams</a>,
-Previous:<a rel=previous accesskey=p href="#Standard%20Streams">Standard Streams</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Opening Streams">Opening Streams</a>,
+Next:<a rel=next accesskey=n href="#Closing Streams">Closing Streams</a>,
+Previous:<a rel=previous accesskey=p href="#Standard Streams">Standard Streams</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Opening Streams</h3>
 
@@ -21987,16 +21536,15 @@
 <p>Everything described in this section is declared in the header file
 <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>fopen</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>)
-</i></td>
+<td align="left"><code>FILE * <b>fopen</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fopen</code> function opens a stream for I/O to the file
 <var>filename</var>, and returns a pointer to the stream.
 
@@ -22035,10 +21583,10 @@
 </dl>
 
 <p>As you can see, <code>+</code> requests a stream that can do both input and
 output.  The ISO standard says that when using such a stream, you must
-call <code>fflush</code> (see <a href="#Stream%20Buffering">Stream Buffering</a>) or a file positioning
-function such as <code>fseek</code> (see <a href="#File%20Positioning">File Positioning</a>) when switching
+call <code>fflush</code> (see <a href="#Stream Buffering">Stream Buffering</a>) or a file positioning
+function such as <code>fseek</code> (see <a href="#File Positioning">File Positioning</a>) when switching
 from reading to writing or vice versa.  Otherwise, internal buffers
 might not be emptied properly.  The GNU C library does not have this
 limitation; you can do arbitrary reading and writing operations on a
 stream in whatever order.
@@ -22051,15 +21599,15 @@
 <var>opentype</var>: the character <code>x</code> insists on creating a new
 file--if a file <var>filename</var> already exists, <code>fopen</code> fails
 rather than opening it.  If you use <code>x</code> you are guaranteed that
 you will not clobber an existing file.  This is equivalent to the
-<code>O_EXCL</code> option to the <code>open</code> function (see <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>).
+<code>O_EXCL</code> option to the <code>open</code> function (see <a href="#Opening and Closing Files">Opening and Closing Files</a>).
 
 <p>The character <code>b</code> in <var>opentype</var> has a standard meaning; it
 requests a binary stream rather than a text stream.  But this makes no
 difference in POSIX systems (including the GNU system).  If both
 <code>+</code> and <code>b</code> are specified, they can appear in either order. 
-See <a href="#Binary%20Streams">Binary Streams</a>.
+See <a href="#Binary Streams">Binary Streams</a>.
 
 <p>If the <var>opentype</var> string contains the sequence
 <code>,ccs=<var>STRING</var></code> then <var>STRING</var> is taken as the name of a
 coded character set and <code>fopen</code> will mark the stream as
@@ -22086,22 +21634,21 @@
 
 <p>You can have multiple streams (or file descriptors) pointing to the same
 file open at the same time.  If you do only input, this works
 straightforwardly, but you must be careful if any output streams are
-included.  See <a href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>.  This is equally true
+included.  See <a href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>.  This is equally true
 whether the streams are in one program (not usual) or in several
 programs (which can easily happen).  It may be advantageous to use the
-file locking facilities to avoid simultaneous access.  See <a href="#File%20Locks">File Locks</a>.
+file locking facilities to avoid simultaneous access.  See <a href="#File Locks">File Locks</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>fopen64</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>)
-</i></td>
+<td align="left"><code>FILE * <b>fopen64</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fopen</code> but the stream it returns a
 pointer for is opened using <code>open64</code>.  Therefore this stream can be
 used even on files larger then 2^31 bytes on 32 bit machines.
@@ -22115,37 +21662,35 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>FOPEN_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>FOPEN_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that
 represents the minimum number of streams that the implementation
 guarantees can be open simultaneously.  You might be able to open more
 than this many streams, but that is not guaranteed.  The value of this
 constant is at least eight, which includes the three standard streams
 <code>stdin</code>, <code>stdout</code>, and <code>stderr</code>.  In POSIX.1 systems this
-value is determined by the <code>OPEN_MAX</code> parameter; see <a href="#General%20Limits">General Limits</a>.  In BSD and GNU, it is controlled by the <code>RLIMIT_NOFILE</code>
-resource limit; see <a href="#Limits%20on%20Resources">Limits on Resources</a>. 
+value is determined by the <code>OPEN_MAX</code> parameter; see <a href="#General Limits">General Limits</a>.  In BSD and GNU, it is controlled by the <code>RLIMIT_NOFILE</code>
+resource limit; see <a href="#Limits on Resources">Limits on Resources</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>freopen</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>FILE * <b>freopen</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like a combination of <code>fclose</code> and <code>fopen</code>. 
 It first closes the stream referred to by <var>stream</var>, ignoring any
 errors that are detected in the process.  (Because errors are ignored,
@@ -22170,16 +21715,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>freopen64</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>FILE * <b>freopen64</b><i> (const char *<var>filename</var>, const char *<var>opentype</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>freopen</code>.  The only difference is that
 on 32 bit machine the stream returned is able to read beyond the
 2^31 bytes limits imposed by the normal interface.  It should be
@@ -22199,16 +21743,15 @@
 introduced a few functions to get this information from the stream
 descriptor and these functions are also available in the GNU C library.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>__freadable</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>__freadable</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__freadable</code> function determines whether the stream
 <var>stream</var> was opened to allow reading.  In this case the return value
 is nonzero.  For write-only streams the function returns zero.
@@ -22217,16 +21760,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>__fwritable</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>__fwritable</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__fwritable</code> function determines whether the stream
 <var>stream</var> was opened to allow writing.  In this case the return value
 is nonzero.  For read-only streams the function returns zero.
@@ -22238,16 +21780,15 @@
 <p>For slightly different kind of problems there are two more functions. 
 They provide even finer-grained information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>__freading</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>__freading</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__freading</code> function determines whether the stream
 <var>stream</var> was last read from or whether it is opened read-only.  In
 this case the return value is nonzero, otherwise it is zero. 
@@ -22259,16 +21800,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>__fwriting</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>__fwriting</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__fwriting</code> function determines whether the stream
 <var>stream</var> was last written to or whether it is opened write-only.  In
 this case the return value is nonzero, otherwise it is zero.
@@ -22277,12 +21817,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Closing%20Streams">Closing Streams</a>,
-Next:<a rel=next accesskey=n href="#Streams%20and%20Threads">Streams and Threads</a>,
-Previous:<a rel=previous accesskey=p href="#Opening%20Streams">Opening Streams</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Closing Streams">Closing Streams</a>,
+Next:<a rel=next accesskey=n href="#Streams and Threads">Streams and Threads</a>,
+Previous:<a rel=previous accesskey=p href="#Opening Streams">Opening Streams</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Closing Streams</h3>
 
@@ -22290,16 +21830,15 @@
 stream and the file is canceled.  After you have closed a stream, you
 cannot perform any additional operations on it.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fclose</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fclose</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function causes <var>stream</var> to be closed and the connection to
 the corresponding file to be broken.  Any buffered output is written
 and any buffered input is discarded.  The <code>fclose</code> function returns
@@ -22320,16 +21859,15 @@
 <p>To close all streams currently available the GNU C Library provides
 another function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fcloseall</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>fcloseall</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function causes all open streams of the process to be closed and
 the connection to corresponding files to be broken.  All buffered data
 is written and any buffered input is discarded.  The <code>fcloseall</code>
@@ -22339,27 +21877,27 @@
 <p>This function should be used only in special situations, e.g., when an
 error occurred and the program must be aborted.  Normally each single
 stream should be closed separately so that problems with individual
 streams can be identified.  It is also problematic since the standard
-streams (see <a href="#Standard%20Streams">Standard Streams</a>) will also be closed.
+streams (see <a href="#Standard Streams">Standard Streams</a>) will also be closed.
 
 <p>The function <code>fcloseall</code> is declared in <code>stdio.h</code>. 
 </td></tr>
 </table>
 
 <p>If the <code>main</code> function to your program returns, or if you call the
-<code>exit</code> function (see <a href="#Normal%20Termination">Normal Termination</a>), all open streams are
+<code>exit</code> function (see <a href="#Normal Termination">Normal Termination</a>), all open streams are
 automatically closed properly.  If your program terminates in any other
-manner, such as by calling the <code>abort</code> function (see <a href="#Aborting%20a%20Program">Aborting a Program</a>) or from a fatal signal (see <a href="#Signal%20Handling">Signal Handling</a>), open streams
+manner, such as by calling the <code>abort</code> function (see <a href="#Aborting a Program">Aborting a Program</a>) or from a fatal signal (see <a href="#Signal Handling">Signal Handling</a>), open streams
 might not be closed properly.  Buffered output might not be flushed and
 files may be incomplete.  For more information on buffering of streams,
-see <a href="#Stream%20Buffering">Stream Buffering</a>.
+see <a href="#Stream Buffering">Stream Buffering</a>.
 
 <p><hr>
-Node:<a name="Streams%20and%20Threads">Streams and Threads</a>,
-Next:<a rel=next accesskey=n href="#Streams%20and%20I18N">Streams and I18N</a>,
-Previous:<a rel=previous accesskey=p href="#Closing%20Streams">Closing Streams</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Streams and Threads">Streams and Threads</a>,
+Next:<a rel=next accesskey=n href="#Streams and I18N">Streams and I18N</a>,
+Previous:<a rel=previous accesskey=p href="#Closing Streams">Closing Streams</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Streams and Threads</h3>
 
@@ -22387,16 +21925,15 @@
 atomicity over all the function calls.  For this it is necessary to
 perform the stream locking in the application code.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>flockfile</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>void <b>flockfile</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>flockfile</code> function acquires the internal locking object
 associated with the stream <var>stream</var>.  This ensures that no other
 thread can explicitly through <code>flockfile</code>/<code>ftrylockfile</code> or
@@ -22406,16 +21943,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ftrylockfile</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>ftrylockfile</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ftrylockfile</code> function tries to acquire the internal locking
 object associated with the stream <var>stream</var> just like
 <code>flockfile</code>.  But unlike <code>flockfile</code> this function does not
@@ -22425,16 +21961,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>funlockfile</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>void <b>funlockfile</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>funlockfile</code> function releases the internal locking object of
 the stream <var>stream</var>. The stream must have been locked before by a
 call to <code>flockfile</code> or a successful call of <code>ftrylockfile</code>. 
@@ -22554,16 +22089,15 @@
 <p>A second way to avoid locking is by using a non-standard function which
 was introduced in Solaris and is available in the GNU C library as well.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>__fsetlocking</b><i> (FILE *<var>stream</var>, int <var>type</var>)
-</i></td>
+<td align="left"><code>int <b>__fsetlocking</b><i> (FILE *<var>stream</var>, int <var>type</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>__fsetlocking</code> function can be used to select whether the
 stream operations will implicitly acquire the locking object of the
@@ -22602,12 +22136,12 @@
 which is written without knowledge about the <code>_unlocked</code> functions
 (or if the programmer was too lazy to use them).
 
 <p><hr>
-Node:<a name="Streams%20and%20I18N">Streams and I18N</a>,
-Next:<a rel=next accesskey=n href="#Simple%20Output">Simple Output</a>,
-Previous:<a rel=previous accesskey=p href="#Streams%20and%20Threads">Streams and Threads</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Streams and I18N">Streams and I18N</a>,
+Next:<a rel=next accesskey=n href="#Simple Output">Simple Output</a>,
+Previous:<a rel=previous accesskey=p href="#Streams and Threads">Streams and Threads</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Streams in Internationalized Applications</h3>
 
@@ -22665,16 +22199,15 @@
 will simply be strange or the application will simply crash.  The
 <code>fwide</code> function can help avoiding this.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fwide</b><i> (FILE *<var>stream</var>, int <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>fwide</b><i> (FILE *<var>stream</var>, int <var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>fwide</code> function can be used to set and query the state of the
 orientation of the stream <var>stream</var>.  If the <var>mode</var> parameter has
@@ -22746,12 +22279,12 @@
 just another good reason to orient the stream explicitly as soon as
 possible, perhaps with a call to <code>fwide</code>.
 
 <p><hr>
-Node:<a name="Simple%20Output">Simple Output</a>,
-Next:<a rel=next accesskey=n href="#Character%20Input">Character Input</a>,
-Previous:<a rel=previous accesskey=p href="#Streams%20and%20I18N">Streams and I18N</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Simple Output">Simple Output</a>,
+Next:<a rel=next accesskey=n href="#Character Input">Character Input</a>,
+Previous:<a rel=previous accesskey=p href="#Streams and I18N">Streams and I18N</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Simple Output by Characters or Lines</h3>
 
@@ -22761,16 +22294,15 @@
 <p>These narrow streams functions are declared in the header file
 <code>stdio.h</code> and the wide stream functions in <code>wchar.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fputc</b><i> (int <var>c</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fputc</b><i> (int <var>c</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fputc</code> function converts the character <var>c</var> to type
 <code>unsigned char</code>, and writes it to the stream <var>stream</var>. 
 <code>EOF</code> is returned if a write error occurs; otherwise the
@@ -22778,47 +22310,44 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>fputwc</b><i> (wchar_t <var>wc</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>fputwc</b><i> (wchar_t <var>wc</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fputwc</code> function writes the wide character <var>wc</var> to the
 stream <var>stream</var>.  <code>WEOF</code> is returned if a write error occurs;
 otherwise the character <var>wc</var> is returned. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fputc_unlocked</b><i> (int <var>c</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fputc_unlocked</b><i> (int <var>c</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fputc_unlocked</code> function is equivalent to the <code>fputc</code>
 function except that it does not implicitly lock the stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>fputwc_unlocked</b><i> (wint_t <var>wc</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>fputwc_unlocked</b><i> (wint_t <var>wc</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fputwc_unlocked</code> function is equivalent to the <code>fputwc</code>
 function except that it does not implicitly lock the stream.
 
@@ -22826,16 +22355,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>putc</b><i> (int <var>c</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>putc</b><i> (int <var>c</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is just like <code>fputc</code>, except that most systems implement it as
 a macro, making it faster.  One consequence is that it may evaluate the
 <var>stream</var> argument more than once, which is an exception to the
@@ -22844,16 +22372,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>putwc</b><i> (wchar_t <var>wc</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>putwc</b><i> (wchar_t <var>wc</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is just like <code>fputwc</code>, except that it can be implement as
 a macro, making it faster.  One consequence is that it may evaluate the
 <var>stream</var> argument more than once, which is an exception to the
@@ -22862,31 +22389,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>putc_unlocked</b><i> (int <var>c</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>putc_unlocked</b><i> (int <var>c</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>putc_unlocked</code> function is equivalent to the <code>putc</code>
 function except that it does not implicitly lock the stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>putwc_unlocked</b><i> (wchar_t <var>wc</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>putwc_unlocked</b><i> (wchar_t <var>wc</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>putwc_unlocked</code> function is equivalent to the <code>putwc</code>
 function except that it does not implicitly lock the stream.
 
@@ -22894,61 +22419,57 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>putchar</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>putchar</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>putchar</code> function is equivalent to <code>putc</code> with
 <code>stdout</code> as the value of the <var>stream</var> argument. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>putwchar</b><i> (wchar_t <var>wc</var>)
-</i></td>
+<td align="left"><code>wint_t <b>putwchar</b><i> (wchar_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>putwchar</code> function is equivalent to <code>putwc</code> with
 <code>stdout</code> as the value of the <var>stream</var> argument. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>putchar_unlocked</b><i> (int <var>c</var>)
-</i></td>
+<td align="left"><code>int <b>putchar_unlocked</b><i> (int <var>c</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>putchar_unlocked</code> function is equivalent to the <code>putchar</code>
 function except that it does not implicitly lock the stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>putwchar_unlocked</b><i> (wchar_t <var>wc</var>)
-</i></td>
+<td align="left"><code>wint_t <b>putwchar_unlocked</b><i> (wchar_t <var>wc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>putwchar_unlocked</code> function is equivalent to the <code>putwchar</code>
 function except that it does not implicitly lock the stream.
 
@@ -22956,16 +22477,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fputs</b><i> (const char *<var>s</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fputs</b><i> (const char *<var>s</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>fputs</code> writes the string <var>s</var> to the stream
 <var>stream</var>.  The terminating null character is not written. 
 This function does <em>not</em> add a newline character, either. 
@@ -22985,16 +22505,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fputws</b><i> (const wchar_t *<var>ws</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fputws</b><i> (const wchar_t *<var>ws</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>fputws</code> writes the wide character string <var>ws</var> to
 the stream <var>stream</var>.  The terminating null character is not written. 
 This function does <em>not</em> add a newline character, either.  It
@@ -23005,16 +22524,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fputs_unlocked</b><i> (const char *<var>s</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fputs_unlocked</b><i> (const char *<var>s</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fputs_unlocked</code> function is equivalent to the <code>fputs</code>
 function except that it does not implicitly lock the stream.
 
@@ -23022,16 +22540,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fputws_unlocked</b><i> (const wchar_t *<var>ws</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fputws_unlocked</b><i> (const wchar_t *<var>ws</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fputws_unlocked</code> function is equivalent to the <code>fputws</code>
 function except that it does not implicitly lock the stream.
 
@@ -23039,16 +22556,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>puts</b><i> (const char *<var>s</var>)
-</i></td>
+<td align="left"><code>int <b>puts</b><i> (const char *<var>s</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>puts</code> function writes the string <var>s</var> to the stream
 <code>stdout</code> followed by a newline.  The terminating null character of
 the string is not written.  (Note that <code>fputs</code> does <em>not</em>
@@ -23064,28 +22580,27 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>putw</b><i> (int <var>w</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>putw</b><i> (int <var>w</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function writes the word <var>w</var> (that is, an <code>int</code>) to
 <var>stream</var>.  It is provided for compatibility with SVID, but we
-recommend you use <code>fwrite</code> instead (see <a href="#Block%20Input%2fOutput">Block Input/Output</a>). 
+recommend you use <code>fwrite</code> instead (see <a href="#Block Input%2fOutput">Block Input/Output</a>). 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Character%20Input">Character Input</a>,
-Next:<a rel=next accesskey=n href="#Line%20Input">Line Input</a>,
-Previous:<a rel=previous accesskey=p href="#Simple%20Output">Simple Output</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Character Input">Character Input</a>,
+Next:<a rel=next accesskey=n href="#Line Input">Line Input</a>,
+Previous:<a rel=previous accesskey=p href="#Simple Output">Simple Output</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Character Input</h3>
 
@@ -23107,16 +22622,15 @@
 you've verified that the result is not <code>EOF</code>, you can be sure that
 it will fit in a <code>char</code> variable without loss of information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fgetc</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fgetc</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads the next character as an <code>unsigned char</code> from
 the stream <var>stream</var> and returns its value, converted to an
 <code>int</code>.  If an end-of-file condition or read error occurs,
@@ -23124,47 +22638,44 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>fgetwc</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>fgetwc</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads the next wide character from the stream <var>stream</var>
 and returns its value.  If an end-of-file condition or read error
 occurs, <code>WEOF</code> is returned instead. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fgetc_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fgetc_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fgetc_unlocked</code> function is equivalent to the <code>fgetc</code>
 function except that it does not implicitly lock the stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>fgetwc_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>fgetwc_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fgetwc_unlocked</code> function is equivalent to the <code>fgetwc</code>
 function except that it does not implicitly lock the stream.
 
@@ -23172,16 +22683,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getc</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>getc</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is just like <code>fgetc</code>, except that it is permissible (and
 typical) for it to be implemented as a macro that evaluates the
 <var>stream</var> argument more than once.  <code>getc</code> is often highly
@@ -23190,16 +22700,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>getwc</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>getwc</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is just like <code>fgetwc</code>, except that it is permissible for it to
 be implemented as a macro that evaluates the <var>stream</var> argument more
 than once.  <code>getwc</code> can be highly optimized, so it is usually the
@@ -23207,31 +22716,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getc_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>getc_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getc_unlocked</code> function is equivalent to the <code>getc</code>
 function except that it does not implicitly lock the stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>getwc_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>getwc_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getwc_unlocked</code> function is equivalent to the <code>getwc</code>
 function except that it does not implicitly lock the stream.
 
@@ -23239,61 +22746,57 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getchar</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>getchar</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getchar</code> function is equivalent to <code>getc</code> with <code>stdin</code>
 as the value of the <var>stream</var> argument. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>getwchar</b><i> (void)
-</i></td>
+<td align="left"><code>wint_t <b>getwchar</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getwchar</code> function is equivalent to <code>getwc</code> with <code>stdin</code>
 as the value of the <var>stream</var> argument. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getchar_unlocked</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>getchar_unlocked</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getchar_unlocked</code> function is equivalent to the <code>getchar</code>
 function except that it does not implicitly lock the stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>getwchar_unlocked</b><i> (void)
-</i></td>
+<td align="left"><code>wint_t <b>getwchar_unlocked</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getwchar_unlocked</code> function is equivalent to the <code>getwchar</code>
 function except that it does not implicitly lock the stream.
 
@@ -23333,31 +22836,30 @@
 }
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getw</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>getw</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads a word (that is, an <code>int</code>) from <var>stream</var>. 
 It's provided for compatibility with SVID.  We recommend you use
-<code>fread</code> instead (see <a href="#Block%20Input%2fOutput">Block Input/Output</a>).  Unlike <code>getc</code>,
+<code>fread</code> instead (see <a href="#Block Input%2fOutput">Block Input/Output</a>).  Unlike <code>getc</code>,
 any <code>int</code> value could be a valid result.  <code>getw</code> returns
 <code>EOF</code> when it encounters end-of-file or an error, but there is no
 way to distinguish this from an input word with value -1. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Line%20Input">Line Input</a>,
+Node:<a name="Line Input">Line Input</a>,
 Next:<a rel=next accesskey=n href="#Unreading">Unreading</a>,
-Previous:<a rel=previous accesskey=p href="#Character%20Input">Character Input</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Previous:<a rel=previous accesskey=p href="#Character Input">Character Input</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Line-Oriented Input</h3>
 
@@ -23375,16 +22877,15 @@
 
 <p>All these functions are declared in <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>getline</b><i> (char **<var>lineptr</var>, size_t *<var>n</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>getline</b><i> (char **<var>lineptr</var>, size_t *<var>n</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads an entire line from <var>stream</var>, storing the text
 (including the newline and a terminating null character) in a buffer
 and storing the buffer address in <code>*<var>lineptr</var></code>.
@@ -23395,9 +22896,9 @@
 <code>getline</code> stores the line in this buffer.  Otherwise,
 <code>getline</code> makes the buffer bigger using <code>realloc</code>, storing the
 new buffer address back in <code>*<var>lineptr</var></code> and the increased size
 back in <code>*<var>n</var></code>. 
-See <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>.
+See <a href="#Unconstrained Allocation">Unconstrained Allocation</a>.
 
 <p>If you set <code>*<var>lineptr</var></code> to a null pointer, and <code>*<var>n</var></code>
 to zero, before the call, then <code>getline</code> allocates the initial
 buffer for you by calling <code>malloc</code>.
@@ -23418,16 +22919,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>getdelim</b><i> (char **<var>lineptr</var>, size_t *<var>n</var>, int <var>delimiter</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>getdelim</b><i> (char **<var>lineptr</var>, size_t *<var>n</var>, int <var>delimiter</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>getline</code> except that the character which
 tells it to stop reading is not necessarily newline.  The argument
 <var>delimiter</var> specifies the delimiter character; <code>getdelim</code> keeps
@@ -23449,16 +22949,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>fgets</b><i> (char *<var>s</var>, int <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>char * <b>fgets</b><i> (char *<var>s</var>, int <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fgets</code> function reads characters from the stream <var>stream</var>
 up to and including a newline character and stores them in the string
 <var>s</var>, adding a null character to mark the end of the string.  You
@@ -23480,16 +22979,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>fgetws</b><i> (wchar_t *<var>ws</var>, int <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>fgetws</b><i> (wchar_t *<var>ws</var>, int <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fgetws</code> function reads wide characters from the stream
 <var>stream</var> up to and including a newline character and stores them in
 the string <var>ws</var>, adding a null wide character to mark the end of the
@@ -23512,16 +23010,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>fgets_unlocked</b><i> (char *<var>s</var>, int <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>char * <b>fgets_unlocked</b><i> (char *<var>s</var>, int <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fgets_unlocked</code> function is equivalent to the <code>fgets</code>
 function except that it does not implicitly lock the stream.
 
@@ -23529,16 +23026,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wchar_t * <b>fgetws_unlocked</b><i> (wchar_t *<var>ws</var>, int <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wchar_t * <b>fgetws_unlocked</b><i> (wchar_t *<var>ws</var>, int <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fgetws_unlocked</code> function is equivalent to the <code>fgetws</code>
 function except that it does not implicitly lock the stream.
 
@@ -23546,16 +23042,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>gets</b><i> (char *<var>s</var>)
-</i></td>
+<td align="left"><code>char * <b>gets</b><i> (char *<var>s</var>)</i></code></td>
 <td align="right">Deprecated function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>gets</code> reads characters from the stream <code>stdin</code>
 up to the next newline character, and stores them in the string <var>s</var>. 
 The newline character is discarded (note that this differs from the
@@ -23573,11 +23068,11 @@
 </table>
 
 <p><hr>
 Node:<a name="Unreading">Unreading</a>,
-Next:<a rel=next accesskey=n href="#Block%20Input%2fOutput">Block Input/Output</a>,
-Previous:<a rel=previous accesskey=p href="#Line%20Input">Line Input</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Next:<a rel=next accesskey=n href="#Block Input%2fOutput">Block Input/Output</a>,
+Previous:<a rel=previous accesskey=p href="#Line Input">Line Input</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Unreading</h3>
 
@@ -23591,15 +23086,15 @@
 Unreading a character makes it available to be input again from the stream,
 by  the next call to <code>fgetc</code> or other input function on that stream.
 
 <ul>
-<li><a accesskey=1 href="#Unreading%20Idea">Unreading Idea</a>:               An explanation of unreading with pictures. 
-<li><a accesskey=2 href="#How%20Unread">How Unread</a>:                   How to call <code>ungetc</code> to do unreading. 
+<li><a accesskey=1 href="#Unreading Idea">Unreading Idea</a>:               An explanation of unreading with pictures. 
+<li><a accesskey=2 href="#How Unread">How Unread</a>:                   How to call <code>ungetc</code> to do unreading. 
 </ul>
 
 <p><hr>
-Node:<a name="Unreading%20Idea">Unreading Idea</a>,
-Next:<a rel=next accesskey=n href="#How%20Unread">How Unread</a>,
+Node:<a name="Unreading Idea">Unreading Idea</a>,
+Next:<a rel=next accesskey=n href="#How Unread">How Unread</a>,
 Up:<a rel=up accesskey=u href="#Unreading">Unreading</a>
 <br>
 
 <h4>What Unreading Means</h4>
@@ -23636,10 +23131,10 @@
 
 <p>so that the next input characters will be <code>9</code> and <code>b</code>.
 
 <p><hr>
-Node:<a name="How%20Unread">How Unread</a>,
-Previous:<a rel=previous accesskey=p href="#Unreading%20Idea">Unreading Idea</a>,
+Node:<a name="How Unread">How Unread</a>,
+Previous:<a rel=previous accesskey=p href="#Unreading Idea">Unreading Idea</a>,
 Up:<a rel=up accesskey=u href="#Unreading">Unreading</a>
 <br>
 
 <h4>Using <code>ungetc</code> To Do Unreading</h4>
@@ -23647,16 +23142,15 @@
 <p>The function to unread a character is called <code>ungetc</code>, because it
 reverses the action of <code>getc</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ungetc</b><i> (int <var>c</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>ungetc</b><i> (int <var>c</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ungetc</code> function pushes back the character <var>c</var> onto the
 input stream <var>stream</var>.  So the next input from <var>stream</var> will
 read <var>c</var> before anything else.
@@ -23679,9 +23173,9 @@
 order that they were pushed.
 
 <p>Pushing back characters doesn't alter the file; only the internal
 buffering for the stream is affected.  If a file positioning function
-(such as <code>fseek</code>, <code>fseeko</code> or <code>rewind</code>; see <a href="#File%20Positioning">File Positioning</a>) is called, any pending pushed-back characters are
+(such as <code>fseek</code>, <code>fseeko</code> or <code>rewind</code>; see <a href="#File Positioning">File Positioning</a>) is called, any pending pushed-back characters are
 discarded.
 
 <p>Unreading a character on a stream that is at end of file clears the
 end-of-file indicator for the stream, because it makes the character of
@@ -23690,16 +23184,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">wint_t <b>ungetwc</b><i> (wint_t <var>wc</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>wint_t <b>ungetwc</b><i> (wint_t <var>wc</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ungetwc</code> function behaves just like <code>ungetc</code> just that it
 pushes back a wide character. 
 </td></tr>
@@ -23726,12 +23219,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Block%20Input%2fOutput">Block Input/Output</a>,
-Next:<a rel=next accesskey=n href="#Formatted%20Output">Formatted Output</a>,
+Node:<a name="Block Input%2fOutput">Block Input/Output</a>,
+Next:<a rel=next accesskey=n href="#Formatted Output">Formatted Output</a>,
 Previous:<a rel=previous accesskey=p href="#Unreading">Unreading</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Block Input/Output</h3>
 
@@ -23756,16 +23249,15 @@
 
 <p>These functions are declared in <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>fread</b><i> (void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>size_t <b>fread</b><i> (void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads up to <var>count</var> objects of size <var>size</var> into
 the array <var>data</var>, from the stream <var>stream</var>.  It returns the
 number of objects actually read, which might be less than <var>count</var> if
@@ -23779,16 +23271,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>fread_unlocked</b><i> (void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>size_t <b>fread_unlocked</b><i> (void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fread_unlocked</code> function is equivalent to the <code>fread</code>
 function except that it does not implicitly lock the stream.
 
@@ -23796,16 +23287,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>fwrite</b><i> (const void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>size_t <b>fwrite</b><i> (const void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function writes up to <var>count</var> objects of size <var>size</var> from
 the array <var>data</var>, to the stream <var>stream</var>.  The return value is
 normally <var>count</var>, if the call succeeds.  Any other value indicates
@@ -23813,16 +23303,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>fwrite_unlocked</b><i> (const void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>size_t <b>fwrite_unlocked</b><i> (const void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fwrite_unlocked</code> function is equivalent to the <code>fwrite</code>
 function except that it does not implicitly lock the stream.
 
@@ -23830,12 +23319,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Formatted%20Output">Formatted Output</a>,
-Next:<a rel=next accesskey=n href="#Customizing%20Printf">Customizing Printf</a>,
-Previous:<a rel=previous accesskey=p href="#Block%20Input%2fOutput">Block Input/Output</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Formatted Output">Formatted Output</a>,
+Next:<a rel=next accesskey=n href="#Customizing Printf">Customizing Printf</a>,
+Previous:<a rel=previous accesskey=p href="#Block Input%2fOutput">Block Input/Output</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Formatted Output</h3>
 
@@ -23850,30 +23339,30 @@
 most concise way to perform output.  These functions are especially
 useful for printing error messages, tables of data, and the like.
 
 <ul>
-<li><a accesskey=1 href="#Formatted%20Output%20Basics">Formatted Output Basics</a>:      Some examples to get you started. 
-<li><a accesskey=2 href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>:     General syntax of conversion
+<li><a accesskey=1 href="#Formatted Output Basics">Formatted Output Basics</a>:      Some examples to get you started. 
+<li><a accesskey=2 href="#Output Conversion Syntax">Output Conversion Syntax</a>:     General syntax of conversion
                                  specifications. 
-<li><a accesskey=3 href="#Table%20of%20Output%20Conversions">Table of Output Conversions</a>:  Summary of output conversions and
+<li><a accesskey=3 href="#Table of Output Conversions">Table of Output Conversions</a>:  Summary of output conversions and
                                  what they do. 
-<li><a accesskey=4 href="#Integer%20Conversions">Integer Conversions</a>:          Details about formatting of integers. 
-<li><a accesskey=5 href="#Floating-Point%20Conversions">Floating-Point Conversions</a>:   Details about formatting of
+<li><a accesskey=4 href="#Integer Conversions">Integer Conversions</a>:          Details about formatting of integers. 
+<li><a accesskey=5 href="#Floating-Point Conversions">Floating-Point Conversions</a>:   Details about formatting of
                                  floating-point numbers. 
-<li><a accesskey=6 href="#Other%20Output%20Conversions">Other Output Conversions</a>:     Details about formatting of strings,
+<li><a accesskey=6 href="#Other Output Conversions">Other Output Conversions</a>:     Details about formatting of strings,
                                  characters, pointers, and the like. 
-<li><a accesskey=7 href="#Formatted%20Output%20Functions">Formatted Output Functions</a>:   Descriptions of the actual functions. 
-<li><a accesskey=8 href="#Dynamic%20Output">Dynamic Output</a>: 		Functions that allocate memory for the output. 
-<li><a accesskey=9 href="#Variable%20Arguments%20Output">Variable Arguments Output</a>:    <code>vprintf</code> and friends. 
-<li><a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>:    What kinds of args does a given template
+<li><a accesskey=7 href="#Formatted Output Functions">Formatted Output Functions</a>:   Descriptions of the actual functions. 
+<li><a accesskey=8 href="#Dynamic Output">Dynamic Output</a>: 		Functions that allocate memory for the output. 
+<li><a accesskey=9 href="#Variable Arguments Output">Variable Arguments Output</a>:    <code>vprintf</code> and friends. 
+<li><a href="#Parsing a Template String">Parsing a Template String</a>:    What kinds of args does a given template
                                  call for? 
-<li><a href="#Example%20of%20Parsing">Example of Parsing</a>:           Sample program using <code>parse_printf_format</code>. 
+<li><a href="#Example of Parsing">Example of Parsing</a>:           Sample program using <code>parse_printf_format</code>. 
 </ul>
 
 <p><hr>
-Node:<a name="Formatted%20Output%20Basics">Formatted Output Basics</a>,
-Next:<a rel=next accesskey=n href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Formatted Output Basics">Formatted Output Basics</a>,
+Next:<a rel=next accesskey=n href="#Output Conversion Syntax">Output Conversion Syntax</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Formatted Output Basics</h4>
 
@@ -23888,15 +23377,15 @@
 formatted and written to the output stream.  For example,
 
 <br><pre>int pct = 37;
 char filename[] = "foo.txt";
-printf ("Processing of `%s' is %d%% finished.\nPlease be patient.\n",
+printf ("Processing of '%s' is %d%% finished.\nPlease be patient.\n",
         filename, pct);
 </pre>
 
 <p>produces output like
 
-<br><pre>Processing of `foo.txt' is 37% finished.
+<br><pre>Processing of 'foo.txt' is 37% finished.
 Please be patient.
 </pre>
 
 <p>This example shows the use of the <code>%d</code> conversion to specify that
@@ -23930,12 +23419,12 @@
 The modifiers are mostly used to make the output look "prettier" in
 tables.
 
 <p><hr>
-Node:<a name="Output%20Conversion%20Syntax">Output Conversion Syntax</a>,
-Next:<a rel=next accesskey=n href="#Table%20of%20Output%20Conversions">Table of Output Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#Formatted%20Output%20Basics">Formatted Output Basics</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Output Conversion Syntax">Output Conversion Syntax</a>,
+Next:<a rel=next accesskey=n href="#Table of Output Conversions">Table of Output Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#Formatted Output Basics">Formatted Output Basics</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Output Conversion Syntax</h4>
 
@@ -23944,9 +23433,9 @@
 string.
 
 <p>Characters in the template string that are not part of a conversion
 specification are printed as-is to the output stream.  Multibyte
-character sequences (see <a href="#Character%20Set%20Handling">Character Set Handling</a>) are permitted in a
+character sequences (see <a href="#Character Set Handling">Character Set Handling</a>) are permitted in a
 template string.
 
 <p>The conversion specifications in a <code>printf</code> template string have
 the general form:
@@ -23976,21 +23465,20 @@
 implementations limit this number to a certainly upper bound.  The exact
 limit can be retrieved by the following constant.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>NL_ARGMAX</b><i>
-</i></td>
+<td align="left"><code><b>NL_ARGMAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of <code>ARGMAX</code> is the maximum value allowed for the
 specification of an positional parameter in a <code>printf</code> call.  The
 actual value in effect at runtime can be retrieved by using
-<code>sysconf</code> using the <code>_SC_NL_ARGMAX</code> parameter see <a href="#Sysconf%20Definition">Sysconf Definition</a>.
+<code>sysconf</code> using the <code>_SC_NL_ARGMAX</code> parameter see <a href="#Sysconf Definition">Sysconf Definition</a>.
 
 <p>Some system have a quite low limit such as 9 for System&nbsp;V
 systems.  The GNU C library has no real limit. 
 </td></tr>
@@ -24046,83 +23534,83 @@
 <code>printf</code> and related functions.  It examines the format string and
 verifies that the correct number and types of arguments are supplied. 
 There is also a GNU C syntax to tell the compiler that a function you
 write uses a <code>printf</code>-style format string. 
-See <a href="gcc.info.html#Function%20Attributes">Declaring Attributes of Functions</a>, for more information.
+See <a href="gcc.info.html#Function Attributes">Declaring Attributes of Functions</a>, for more information.
 
 <p><hr>
-Node:<a name="Table%20of%20Output%20Conversions">Table of Output Conversions</a>,
-Next:<a rel=next accesskey=n href="#Integer%20Conversions">Integer Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Table of Output Conversions">Table of Output Conversions</a>,
+Next:<a rel=next accesskey=n href="#Integer Conversions">Integer Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#Output Conversion Syntax">Output Conversion Syntax</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Table of Output Conversions</h4>
 
 <p>Here is a table summarizing what all the different conversions do:
 
 <dl>
 <dt><code>%d</code>, <code>%i</code>
-<dd>Print an integer as a signed decimal number.  See <a href="#Integer%20Conversions">Integer Conversions</a>, for details.  <code>%d</code> and <code>%i</code> are synonymous for
+<dd>Print an integer as a signed decimal number.  See <a href="#Integer Conversions">Integer Conversions</a>, for details.  <code>%d</code> and <code>%i</code> are synonymous for
 output, but are different when used with <code>scanf</code> for input
-(see <a href="#Table%20of%20Input%20Conversions">Table of Input Conversions</a>).
+(see <a href="#Table of Input Conversions">Table of Input Conversions</a>).
 
 <br><dt><code>%o</code>
-<dd>Print an integer as an unsigned octal number.  See <a href="#Integer%20Conversions">Integer Conversions</a>, for details.
+<dd>Print an integer as an unsigned octal number.  See <a href="#Integer Conversions">Integer Conversions</a>, for details.
 
 <br><dt><code>%u</code>
-<dd>Print an integer as an unsigned decimal number.  See <a href="#Integer%20Conversions">Integer Conversions</a>, for details.
+<dd>Print an integer as an unsigned decimal number.  See <a href="#Integer Conversions">Integer Conversions</a>, for details.
 
 <br><dt><code>%x</code>, <code>%X</code>
 <dd>Print an integer as an unsigned hexadecimal number.  <code>%x</code> uses
-lower-case letters and <code>%X</code> uses upper-case.  See <a href="#Integer%20Conversions">Integer Conversions</a>, for details.
+lower-case letters and <code>%X</code> uses upper-case.  See <a href="#Integer Conversions">Integer Conversions</a>, for details.
 
 <br><dt><code>%f</code>
 <dd>Print a floating-point number in normal (fixed-point) notation. 
-See <a href="#Floating-Point%20Conversions">Floating-Point Conversions</a>, for details.
+See <a href="#Floating-Point Conversions">Floating-Point Conversions</a>, for details.
 
 <br><dt><code>%e</code>, <code>%E</code>
 <dd>Print a floating-point number in exponential notation.  <code>%e</code> uses
-lower-case letters and <code>%E</code> uses upper-case.  See <a href="#Floating-Point%20Conversions">Floating-Point Conversions</a>, for details.
+lower-case letters and <code>%E</code> uses upper-case.  See <a href="#Floating-Point Conversions">Floating-Point Conversions</a>, for details.
 
 <br><dt><code>%g</code>, <code>%G</code>
 <dd>Print a floating-point number in either normal or exponential notation,
 whichever is more appropriate for its magnitude.  <code>%g</code> uses
-lower-case letters and <code>%G</code> uses upper-case.  See <a href="#Floating-Point%20Conversions">Floating-Point Conversions</a>, for details.
+lower-case letters and <code>%G</code> uses upper-case.  See <a href="#Floating-Point Conversions">Floating-Point Conversions</a>, for details.
 
 <br><dt><code>%a</code>, <code>%A</code>
 <dd>Print a floating-point number in a hexadecimal fractional notation which
 the exponent to base 2 represented in decimal digits.  <code>%a</code> uses
-lower-case letters and <code>%A</code> uses upper-case.  See <a href="#Floating-Point%20Conversions">Floating-Point Conversions</a>, for details.
+lower-case letters and <code>%A</code> uses upper-case.  See <a href="#Floating-Point Conversions">Floating-Point Conversions</a>, for details.
 
 <br><dt><code>%c</code>
-<dd>Print a single character.  See <a href="#Other%20Output%20Conversions">Other Output Conversions</a>.
+<dd>Print a single character.  See <a href="#Other Output Conversions">Other Output Conversions</a>.
 
 <br><dt><code>%C</code>
 <dd>This is an alias for <code>%lc</code> which is supported for compatibility
 with the Unix standard.
 
 <br><dt><code>%s</code>
-<dd>Print a string.  See <a href="#Other%20Output%20Conversions">Other Output Conversions</a>.
+<dd>Print a string.  See <a href="#Other Output Conversions">Other Output Conversions</a>.
 
 <br><dt><code>%S</code>
 <dd>This is an alias for <code>%ls</code> which is supported for compatibility
 with the Unix standard.
 
 <br><dt><code>%p</code>
-<dd>Print the value of a pointer.  See <a href="#Other%20Output%20Conversions">Other Output Conversions</a>.
+<dd>Print the value of a pointer.  See <a href="#Other Output Conversions">Other Output Conversions</a>.
 
 <br><dt><code>%n</code>
-<dd>Get the number of characters printed so far.  See <a href="#Other%20Output%20Conversions">Other Output Conversions</a>. 
+<dd>Get the number of characters printed so far.  See <a href="#Other Output Conversions">Other Output Conversions</a>. 
 Note that this conversion specification never produces any output.
 
 <br><dt><code>%m</code>
 <dd>Print the string corresponding to the value of <code>errno</code>. 
 (This is a GNU extension.) 
-See <a href="#Other%20Output%20Conversions">Other Output Conversions</a>.
+See <a href="#Other Output Conversions">Other Output Conversions</a>.
 
 <br><dt><code>%%</code>
-<dd>Print a literal <code>%</code> character.  See <a href="#Other%20Output%20Conversions">Other Output Conversions</a>. 
+<dd>Print a literal <code>%</code> character.  See <a href="#Other Output Conversions">Other Output Conversions</a>. 
 </dl>
 
 <p>If the syntax of a conversion specification is invalid, unpredictable
 things will happen, so don't do this.  If there aren't enough function
@@ -24132,12 +23620,12 @@
 arguments than conversion specifications, the extra argument values are
 simply ignored; this is sometimes useful.
 
 <p><hr>
-Node:<a name="Integer%20Conversions">Integer Conversions</a>,
-Next:<a rel=next accesskey=n href="#Floating-Point%20Conversions">Floating-Point Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#Table%20of%20Output%20Conversions">Table of Output Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Integer Conversions">Integer Conversions</a>,
+Next:<a rel=next accesskey=n href="#Floating-Point Conversions">Floating-Point Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#Table of Output Conversions">Table of Output Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Integer Conversions</h4>
 
@@ -24174,14 +23662,14 @@
 <code>0</code>, as if by increasing the precision.  For <code>%x</code> or
 <code>%X</code>, this prefixes a leading <code>0x</code> or <code>0X</code> (respectively)
 to the result.  This doesn't do anything useful for the <code>%d</code>,
 <code>%i</code>, or <code>%u</code> conversions.  Using this flag produces output
-which can be parsed by the <code>strtoul</code> function (see <a href="#Parsing%20of%20Integers">Parsing of Integers</a>) and <code>scanf</code> with the <code>%i</code> conversion
-(see <a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>).
+which can be parsed by the <code>strtoul</code> function (see <a href="#Parsing of Integers">Parsing of Integers</a>) and <code>scanf</code> with the <code>%i</code> conversion
+(see <a href="#Numeric Input Conversions">Numeric Input Conversions</a>).
 
 <br><dt><code>'</code>
 <dd>Separate the digits into groups as specified by the locale specified for
-the <code>LC_NUMERIC</code> category; see <a href="#General%20Numeric">General Numeric</a>.  This flag is a
+the <code>LC_NUMERIC</code> category; see <a href="#General Numeric">General Numeric</a>.  This flag is a
 GNU extension.
 
 <br><dt><code>0</code>
 <dd>Pad the field with zeros instead of spaces.  The zeros are placed after
@@ -24288,12 +23776,12 @@
 |100000|303240|186a0|186A0|0303240|0x186a0|0X186A0|0x000186a0|
 </pre>
 
 <p><hr>
-Node:<a name="Floating-Point%20Conversions">Floating-Point Conversions</a>,
-Next:<a rel=next accesskey=n href="#Other%20Output%20Conversions">Other Output Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#Integer%20Conversions">Integer Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Floating-Point Conversions">Floating-Point Conversions</a>,
+Next:<a rel=next accesskey=n href="#Other Output Conversions">Other Output Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#Integer Conversions">Integer Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Floating-Point Conversions</h4>
 
@@ -24334,9 +23822,9 @@
 the decimal-point character is equal to the precision.  If the precision
 is zero it is determined to be large enough to provide an exact
 representation of the number (or it is large enough to distinguish two
 adjacent values if the <code>FLT_RADIX</code> is not a power of 2,
-see <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>).  For the <code>%a</code> conversion
+see <a href="#Floating Point Parameters">Floating Point Parameters</a>).  For the <code>%a</code> conversion
 lower-case characters are used to represent the hexadecimal number and
 the prefix and exponent sign are printed as <code>0x</code> and <code>p</code>
 respectively.  Otherwise upper-case characters are used and <code>0X</code>
 and <code>P</code> are used for the representation of prefix and exponent
@@ -24373,9 +23861,9 @@
 
 <br><dt><code>'</code>
 <dd>Separate the digits of the integer part of the result into groups as
 specified by the locale specified for the <code>LC_NUMERIC</code> category;
-see <a href="#General%20Numeric">General Numeric</a>.  This flag is a GNU extension.
+see <a href="#General Numeric">General Numeric</a>.  This flag is a GNU extension.
 
 <br><dt><code>0</code>
 <dd>Pad the field with zeros instead of spaces; the zeros are placed
 after any sign.  This flag is ignored if the <code>-</code> flag is also
@@ -24428,12 +23916,12 @@
 
 <p>Notice how the <code>%g</code> conversion drops trailing zeros.
 
 <p><hr>
-Node:<a name="Other%20Output%20Conversions">Other Output Conversions</a>,
-Next:<a rel=next accesskey=n href="#Formatted%20Output%20Functions">Formatted Output Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Floating-Point%20Conversions">Floating-Point Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Other Output Conversions">Other Output Conversions</a>,
+Next:<a rel=next accesskey=n href="#Formatted Output Functions">Formatted Output Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Floating-Point Conversions">Floating-Point Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Other Output Conversions</h4>
 
@@ -24480,16 +23968,16 @@
 is more useful than crashing.  But it's not good practice to pass a null
 argument intentionally.
 
 <p>The <code>%m</code> conversion prints the string corresponding to the error
-code in <code>errno</code>.  See <a href="#Error%20Messages">Error Messages</a>.  Thus:
+code in <code>errno</code>.  See <a href="#Error Messages">Error Messages</a>.  Thus:
 
-<br><pre>fprintf (stderr, "can't open `%s': %m\n", filename);
+<br><pre>fprintf (stderr, "can't open '%s': %m\n", filename);
 </pre>
 
 <p>is equivalent to:
 
-<br><pre>fprintf (stderr, "can't open `%s': %s\n", filename, strerror (errno));
+<br><pre>fprintf (stderr, "can't open '%s': %s\n", filename, strerror (errno));
 </pre>
 
 <p>The <code>%m</code> conversion is a GNU C library extension.
 
@@ -24540,12 +24028,12 @@
 conversion doesn't use an argument, and no flags, field width,
 precision, or type modifiers are permitted.
 
 <p><hr>
-Node:<a name="Formatted%20Output%20Functions">Formatted Output Functions</a>,
-Next:<a rel=next accesskey=n href="#Dynamic%20Output">Dynamic Output</a>,
-Previous:<a rel=previous accesskey=p href="#Other%20Output%20Conversions">Other Output Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Formatted Output Functions">Formatted Output Functions</a>,
+Next:<a rel=next accesskey=n href="#Dynamic Output">Dynamic Output</a>,
+Previous:<a rel=previous accesskey=p href="#Other Output Conversions">Other Output Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Formatted Output Functions</h4>
 
@@ -24556,16 +24044,15 @@
 the easiest way to make sure you have all the right prototypes is to
 just include <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>printf</b><i> (const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>printf</b><i> (const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>printf</code> function prints the optional arguments under the
 control of the template string <var>template</var> to the stream
 <code>stdout</code>.  It returns the number of characters printed, or a
@@ -24573,16 +24060,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wprintf</b><i> (const wchar_t *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>wprintf</b><i> (const wchar_t *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wprintf</code> function prints the optional arguments under the
 control of the wide template string <var>template</var> to the stream
 <code>stdout</code>.  It returns the number of wide characters printed, or a
@@ -24590,46 +24076,43 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fprintf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>fprintf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is just like <code>printf</code>, except that the output is
 written to the stream <var>stream</var> instead of <code>stdout</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fwprintf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>fwprintf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is just like <code>wprintf</code>, except that the output is
 written to the stream <var>stream</var> instead of <code>stdout</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sprintf</b><i> (char *<var>s</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>sprintf</b><i> (char *<var>s</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>printf</code>, except that the output is stored in the character
 array <var>s</var> instead of written to a stream.  A null character is written
 to mark the end of the string.
@@ -24639,9 +24122,9 @@
 
 <p>The behavior of this function is undefined if copying takes place
 between objects that overlap--for example, if <var>s</var> is also given
 as an argument to be printed under control of the <code>%s</code> conversion. 
-See <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+See <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <p><strong>Warning:</strong> The <code>sprintf</code> function can be <strong>dangerous</strong>
 because it can potentially output more characters than can fit in the
 allocation size of the string <var>s</var>.  Remember that the field width
@@ -24652,16 +24135,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>swprintf</b><i> (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>swprintf</b><i> (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>wprintf</code>, except that the output is stored in the
 wide character array <var>ws</var> instead of written to a stream.  A null
 wide character is written to mark the end of the string.  The <var>size</var>
@@ -24684,16 +24166,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>snprintf</b><i> (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>snprintf</b><i> (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>snprintf</code> function is similar to <code>sprintf</code>, except that
 the <var>size</var> argument specifies the maximum number of characters to
 produce.  The trailing null character is counted towards this limit, so
@@ -24746,31 +24227,30 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Dynamic%20Output">Dynamic Output</a>,
-Next:<a rel=next accesskey=n href="#Variable%20Arguments%20Output">Variable Arguments Output</a>,
-Previous:<a rel=previous accesskey=p href="#Formatted%20Output%20Functions">Formatted Output Functions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Dynamic Output">Dynamic Output</a>,
+Next:<a rel=next accesskey=n href="#Variable Arguments Output">Variable Arguments Output</a>,
+Previous:<a rel=previous accesskey=p href="#Formatted Output Functions">Formatted Output Functions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Dynamically Allocating Formatted Output</h4>
 
 <p>The functions in this section do formatted output and place the results
 in dynamically allocated memory.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>asprintf</b><i> (char **<var>ptr</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>asprintf</b><i> (char **<var>ptr</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>sprintf</code>, except that it dynamically
-allocates a string (as with <code>malloc</code>; see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>) to hold the output, instead of putting the output in a
+allocates a string (as with <code>malloc</code>; see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>) to hold the output, instead of putting the output in a
 buffer you allocate in advance.  The <var>ptr</var> argument should be the
 address of a <code>char *</code> object, and <code>asprintf</code> stores a pointer
 to the newly allocated string at that location.
 
@@ -24795,31 +24275,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_printf</b><i> (struct obstack *<var>obstack</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>obstack_printf</b><i> (struct obstack *<var>obstack</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>asprintf</code>, except that it uses the
 obstack <var>obstack</var> to allocate the space.  See <a href="#Obstacks">Obstacks</a>.
 
 <p>The characters are written onto the end of the current object. 
 To get at them, you must finish the object with <code>obstack_finish</code>
-(see <a href="#Growing%20Objects">Growing Objects</a>). 
+(see <a href="#Growing Objects">Growing Objects</a>). 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Variable%20Arguments%20Output">Variable Arguments Output</a>,
-Next:<a rel=next accesskey=n href="#Parsing%20a%20Template%20String">Parsing a Template String</a>,
-Previous:<a rel=previous accesskey=p href="#Dynamic%20Output">Dynamic Output</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Variable Arguments Output">Variable Arguments Output</a>,
+Next:<a rel=next accesskey=n href="#Parsing a Template String">Parsing a Template String</a>,
+Previous:<a rel=previous accesskey=p href="#Dynamic Output">Dynamic Output</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Variable Arguments Output Functions</h4>
 
@@ -24844,13 +24323,13 @@
 <br><pre>#define myprintf(a, b, c, d, e, rest...) \
             printf (mytemplate , ## rest...)
 </pre>
 
-<p>See <a href="gcc.info.html#Macro%20Varargs">Macros with Variable Numbers of Arguments</a>, for details.  But this is limited to macros,
+<p>See <a href="gcc.info.html#Macro Varargs">Macros with Variable Numbers of Arguments</a>, for details.  But this is limited to macros,
 and does not apply to real functions at all.
 
 <p>Before calling <code>vprintf</code> or the other functions listed in this
-section, you <em>must</em> call <code>va_start</code> (see <a href="#Variadic%20Functions">Variadic Functions</a>) to initialize a pointer to the variable arguments.  Then you
+section, you <em>must</em> call <code>va_start</code> (see <a href="#Variadic Functions">Variadic Functions</a>) to initialize a pointer to the variable arguments.  Then you
 can call <code>va_arg</code> to fetch the arguments that you want to handle
 yourself.  This advances the pointer past those arguments.
 
 <p>Once your <code>va_list</code> pointer is pointing at the argument of your
@@ -24875,138 +24354,129 @@
 
 <p>Prototypes for these functions are declared in <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vprintf</b><i> (const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vprintf</b><i> (const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>printf</code> except that, instead of taking
 a variable number of arguments directly, it takes an argument list
 pointer <var>ap</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vwprintf</b><i> (const wchar_t *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vwprintf</b><i> (const wchar_t *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>wprintf</code> except that, instead of taking
 a variable number of arguments directly, it takes an argument list
 pointer <var>ap</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vfprintf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vfprintf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>fprintf</code> with the variable argument list
 specified directly as for <code>vprintf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vfwprintf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vfwprintf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>fwprintf</code> with the variable argument list
 specified directly as for <code>vwprintf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vsprintf</b><i> (char *<var>s</var>, const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vsprintf</b><i> (char *<var>s</var>, const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>sprintf</code> with the variable argument list
 specified directly as for <code>vprintf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vswprintf</b><i> (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vswprintf</b><i> (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>swprintf</code> with the variable argument list
 specified directly as for <code>vwprintf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vsnprintf</b><i> (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vsnprintf</b><i> (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>snprintf</code> with the variable argument list
 specified directly as for <code>vprintf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vasprintf</b><i> (char **<var>ptr</var>, const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vasprintf</b><i> (char **<var>ptr</var>, const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>vasprintf</code> function is the equivalent of <code>asprintf</code> with the
 variable argument list specified directly as for <code>vprintf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>obstack_vprintf</b><i> (struct obstack *<var>obstack</var>, const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>obstack_vprintf</b><i> (struct obstack *<var>obstack</var>, const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>obstack_vprintf</code> function is the equivalent of
 <code>obstack_printf</code> with the variable argument list specified directly
 as for <code>vprintf</code>. 
@@ -25015,9 +24485,9 @@
 
 <p>Here's an example showing how you might use <code>vfprintf</code>.  This is a
 function that prints error messages to the stream <code>stderr</code>, along
 with a prefix indicating the name of the program
-(see <a href="#Error%20Messages">Error Messages</a>, for a description of
+(see <a href="#Error Messages">Error Messages</a>, for a description of
 <code>program_invocation_short_name</code>).
 
 <br><pre>#include &lt;stdio.h&gt;
 #include &lt;stdarg.h&gt;
@@ -25036,9 +24506,9 @@
 </pre>
 
 <p>You could call <code>eprintf</code> like this:
 
-<br><pre>eprintf ("file `%s' does not exist\n", filename);
+<br><pre>eprintf ("file '%s' does not exist\n", filename);
 </pre>
 
 <p>In GNU C, there is a special construct you can use to let the compiler
 know that a function uses a <code>printf</code>-style format string.  Then it
@@ -25050,18 +24520,18 @@
         __attribute__ ((format (printf, 1, 2)));
 </pre>
 
 <p>This tells the compiler that <code>eprintf</code> uses a format string like
-<code>printf</code> (as opposed to <code>scanf</code>; see <a href="#Formatted%20Input">Formatted Input</a>);
+<code>printf</code> (as opposed to <code>scanf</code>; see <a href="#Formatted Input">Formatted Input</a>);
 the format string appears as the first argument;
 and the arguments to satisfy the format begin with the second. 
-See <a href="gcc.info.html#Function%20Attributes">Declaring Attributes of Functions</a>, for more information.
+See <a href="gcc.info.html#Function Attributes">Declaring Attributes of Functions</a>, for more information.
 
 <p><hr>
-Node:<a name="Parsing%20a%20Template%20String">Parsing a Template String</a>,
-Next:<a rel=next accesskey=n href="#Example%20of%20Parsing">Example of Parsing</a>,
-Previous:<a rel=previous accesskey=p href="#Variable%20Arguments%20Output">Variable Arguments Output</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Parsing a Template String">Parsing a Template String</a>,
+Next:<a rel=next accesskey=n href="#Example of Parsing">Example of Parsing</a>,
+Previous:<a rel=previous accesskey=p href="#Variable Arguments Output">Variable Arguments Output</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Parsing a Template String</h4>
 
@@ -25074,16 +24544,15 @@
 <p>All the symbols described in this section are declared in the header
 file <code>printf.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>parse_printf_format</b><i> (const char *<var>template</var>, size_t <var>n</var>, int *<var>argtypes</var>)
-</i></td>
+<td align="left"><code>size_t <b>parse_printf_format</b><i> (const char *<var>template</var>, size_t <var>n</var>, int *<var>argtypes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns information about the number and types of
 arguments expected by the <code>printf</code> template string <var>template</var>. 
 The information is stored in the array <var>argtypes</var>; each element of
@@ -25105,16 +24574,15 @@
 <p>The argument types are encoded as a combination of a basic type and
 modifier flag bits.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PA_FLAG_MASK</b><i>
-</i></td>
+<td align="left"><code>int <b>PA_FLAG_MASK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is a bitmask for the type modifier flag bits.  You can write
 the expression <code>(argtypes[i] &amp; PA_FLAG_MASK)</code> to extract just the
 flag bits for an argument, or <code>(argtypes[i] &amp; ~PA_FLAG_MASK)</code> to
@@ -25181,11 +24649,11 @@
 a base type of <code>PA_DOUBLE</code> to indicate a type of <code>long double</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Example%20of%20Parsing">Example of Parsing</a>,
-Previous:<a rel=previous accesskey=p href="#Parsing%20a%20Template%20String">Parsing a Template String</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Output">Formatted Output</a>
+Node:<a name="Example of Parsing">Example of Parsing</a>,
+Previous:<a rel=previous accesskey=p href="#Parsing a Template String">Parsing a Template String</a>,
+Up:<a rel=up accesskey=u href="#Formatted Output">Formatted Output</a>
 <br>
 
 <h4>Example of Parsing a Template String</h4>
 
@@ -25257,12 +24725,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Customizing%20Printf">Customizing Printf</a>,
-Next:<a rel=next accesskey=n href="#Formatted%20Input">Formatted Input</a>,
-Previous:<a rel=previous accesskey=p href="#Formatted%20Output">Formatted Output</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Customizing Printf">Customizing Printf</a>,
+Next:<a rel=next accesskey=n href="#Formatted Input">Formatted Input</a>,
+Previous:<a rel=previous accesskey=p href="#Formatted Output">Formatted Output</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Customizing <code>printf</code></h3>
 
@@ -25270,57 +24738,56 @@
 for <code>printf</code> template strings, to teach <code>printf</code> clever ways
 to print the important data structures of your program.
 
 <p>The way you do this is by registering the conversion with the function
-<code>register_printf_function</code>; see <a href="#Registering%20New%20Conversions">Registering New Conversions</a>. 
+<code>register_printf_function</code>; see <a href="#Registering New Conversions">Registering New Conversions</a>. 
 One of the arguments you pass to this function is a pointer to a handler
-function that produces the actual output; see <a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>, for information on how to write this function.
+function that produces the actual output; see <a href="#Defining the Output Handler">Defining the Output Handler</a>, for information on how to write this function.
 
 <p>You can also install a function that just returns information about the
 number and type of arguments expected by the conversion specifier. 
-See <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>, for information about this.
+See <a href="#Parsing a Template String">Parsing a Template String</a>, for information about this.
 
 <p>The facilities of this section are declared in the header file
 <code>printf.h</code>.
 
 <ul>
-<li><a accesskey=1 href="#Registering%20New%20Conversions">Registering New Conversions</a>:          Using <code>register_printf_function</code>
+<li><a accesskey=1 href="#Registering New Conversions">Registering New Conversions</a>:          Using <code>register_printf_function</code>
                                          to register a new output conversion. 
-<li><a accesskey=2 href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>:         The handler must be able to get
+<li><a accesskey=2 href="#Conversion Specifier Options">Conversion Specifier Options</a>:         The handler must be able to get
                                          the options specified in the
                                          template when it is called. 
-<li><a accesskey=3 href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>:          Defining the handler and arginfo
+<li><a accesskey=3 href="#Defining the Output Handler">Defining the Output Handler</a>:          Defining the handler and arginfo
                                          functions that are passed as arguments
                                          to <code>register_printf_function</code>. 
-<li><a accesskey=4 href="#Printf%20Extension%20Example">Printf Extension Example</a>:             How to define a <code>printf</code>
+<li><a accesskey=4 href="#Printf Extension Example">Printf Extension Example</a>:             How to define a <code>printf</code>
                                          handler function. 
-<li><a accesskey=5 href="#Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>:           Predefined <code>printf</code> handlers. 
+<li><a accesskey=5 href="#Predefined Printf Handlers">Predefined Printf Handlers</a>:           Predefined <code>printf</code> handlers. 
 </ul>
 
 <p><strong>Portability Note:</strong> The ability to extend the syntax of
 <code>printf</code> template strings is a GNU extension.  ISO standard C has
 nothing similar.
 
 <p><hr>
-Node:<a name="Registering%20New%20Conversions">Registering New Conversions</a>,
-Next:<a rel=next accesskey=n href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>,
-Up:<a rel=up accesskey=u href="#Customizing%20Printf">Customizing Printf</a>
+Node:<a name="Registering New Conversions">Registering New Conversions</a>,
+Next:<a rel=next accesskey=n href="#Conversion Specifier Options">Conversion Specifier Options</a>,
+Up:<a rel=up accesskey=u href="#Customizing Printf">Customizing Printf</a>
 <br>
 
 <h4>Registering New Conversions</h4>
 
 <p>The function to register a new output conversion is
 <code>register_printf_function</code>, declared in <code>printf.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>register_printf_function</b><i> (int <var>spec</var>, printf_function <var>handler-function</var>, printf_arginfo_function <var>arginfo-function</var>)
-</i></td>
+<td align="left"><code>int <b>register_printf_function</b><i> (int <var>spec</var>, printf_function <var>handler-function</var>, printf_arginfo_function <var>arginfo-function</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function defines the conversion specifier character <var>spec</var>. 
 Thus, if <var>spec</var> is <code>'Y'</code>, it defines the conversion <code>%Y</code>. 
 You can redefine the built-in conversions like <code>%s</code>, but flag
@@ -25331,15 +24798,15 @@
 standardized in future editions of the standard.
 
 <p>The <var>handler-function</var> is the function called by <code>printf</code> and
 friends when this conversion appears in a template string. 
-See <a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>, for information about how to define
+See <a href="#Defining the Output Handler">Defining the Output Handler</a>, for information about how to define
 a function to pass as this argument.  If you specify a null pointer, any
 existing handler function for <var>spec</var> is removed.
 
 <p>The <var>arginfo-function</var> is the function called by
 <code>parse_printf_format</code> when this conversion appears in a
-template string.  See <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>, for information
+template string.  See <a href="#Parsing a Template String">Parsing a Template String</a>, for information
 about this.
 
 <p><strong>Attention:</strong> In the GNU C library versions before 2.0 the
 <var>arginfo-function</var> function did not need to be installed unless
@@ -25356,12 +24823,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Conversion%20Specifier%20Options">Conversion Specifier Options</a>,
-Next:<a rel=next accesskey=n href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>,
-Previous:<a rel=previous accesskey=p href="#Registering%20New%20Conversions">Registering New Conversions</a>,
-Up:<a rel=up accesskey=u href="#Customizing%20Printf">Customizing Printf</a>
+Node:<a name="Conversion Specifier Options">Conversion Specifier Options</a>,
+Next:<a rel=next accesskey=n href="#Defining the Output Handler">Defining the Output Handler</a>,
+Previous:<a rel=previous accesskey=p href="#Registering New Conversions">Registering New Conversions</a>,
+Up:<a rel=up accesskey=u href="#Customizing Printf">Customizing Printf</a>
 <br>
 
 <h4>Conversion Specifier Options</h4>
 
@@ -25376,16 +24843,15 @@
 specifier.  This data type is declared in the header file
 <code>printf.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct printf_info</b><i>
-</i></td>
+<td align="left"><code><b>struct printf_info</b><i></i></code></td>
 <td align="right">Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used to pass information about the options appearing
 in an instance of a conversion specifier in a <code>printf</code> template
 string to the handler and arginfo functions for that specifier.  It
@@ -25461,12 +24927,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Defining%20the%20Output%20Handler">Defining the Output Handler</a>,
-Next:<a rel=next accesskey=n href="#Printf%20Extension%20Example">Printf Extension Example</a>,
-Previous:<a rel=previous accesskey=p href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>,
-Up:<a rel=up accesskey=u href="#Customizing%20Printf">Customizing Printf</a>
+Node:<a name="Defining the Output Handler">Defining the Output Handler</a>,
+Next:<a rel=next accesskey=n href="#Printf Extension Example">Printf Extension Example</a>,
+Previous:<a rel=previous accesskey=p href="#Conversion Specifier Options">Conversion Specifier Options</a>,
+Up:<a rel=up accesskey=u href="#Customizing Printf">Customizing Printf</a>
 <br>
 
 <h4>Defining the Output Handler</h4>
 
@@ -25488,9 +24954,9 @@
 
 <p>The <var>info</var> argument is a pointer to a structure that contains
 information about the various options that were included with the
 conversion in the template string.  You should not modify this structure
-inside your handler function.  See <a href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>, for
+inside your handler function.  See <a href="#Conversion Specifier Options">Conversion Specifier Options</a>, for
 a description of this data structure.
 
 <p>The <var>args</var> is a vector of pointers to the arguments data. 
 The number of arguments was determined by calling the argument
@@ -25500,16 +24966,15 @@
 does: it should return the number of characters it has written, or a
 negative value to indicate an error.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>printf_function</b><i>
-</i></td>
+<td align="left"><code><b>printf_function</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type that a handler function should have. 
 </td></tr>
 </table>
@@ -25532,27 +24997,26 @@
 various <code>PA_</code> macros.  (You will notice that this is the same
 calling convention <code>parse_printf_format</code> itself uses.)
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>printf_arginfo_function</b><i>
-</i></td>
+<td align="left"><code><b>printf_arginfo_function</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This type is used to describe functions that return information about
 the number and type of arguments used by a conversion specifier. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Printf%20Extension%20Example">Printf Extension Example</a>,
-Next:<a rel=next accesskey=n href="#Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>,
-Previous:<a rel=previous accesskey=p href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>,
-Up:<a rel=up accesskey=u href="#Customizing%20Printf">Customizing Printf</a>
+Node:<a name="Printf Extension Example">Printf Extension Example</a>,
+Next:<a rel=next accesskey=n href="#Predefined Printf Handlers">Predefined Printf Handlers</a>,
+Previous:<a rel=previous accesskey=p href="#Defining the Output Handler">Defining the Output Handler</a>,
+Up:<a rel=up accesskey=u href="#Customizing Printf">Customizing Printf</a>
 <br>
 
 <h4><code>printf</code> Extension Example</h4>
 
@@ -25639,11 +25103,11 @@
 |&lt;Widget 0xffeffb7c: mywidget&gt;      |
 </pre>
 
 <p><hr>
-Node:<a name="Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>,
-Previous:<a rel=previous accesskey=p href="#Printf%20Extension%20Example">Printf Extension Example</a>,
-Up:<a rel=up accesskey=u href="#Customizing%20Printf">Customizing Printf</a>
+Node:<a name="Predefined Printf Handlers">Predefined Printf Handlers</a>,
+Previous:<a rel=previous accesskey=p href="#Printf Extension Example">Printf Extension Example</a>,
+Up:<a rel=up accesskey=u href="#Customizing Printf">Customizing Printf</a>
 <br>
 
 <h4>Predefined <code>printf</code> Handlers</h4>
 
@@ -25651,16 +25115,15 @@
 <code>printf</code> handler extension.  There are two functions available
 which implement a special way to print floating-point numbers.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>printf_size</b><i> (FILE *<var>fp</var>, const struct printf_info *<var>info</var>, const void *const *<var>args</var>)
-</i></td>
+<td align="left"><code>int <b>printf_size</b><i> (FILE *<var>fp</var>, const struct printf_info *<var>info</var>, const void *const *<var>args</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Print a given floating point number as for the format <code>%f</code> except
 that there is a postfix character indicating the divisor for the
 number to make this less than 1000.  There are two possible divisors:
@@ -25680,16 +25143,15 @@
 <p>Due to the requirements of <code>register_printf_function</code> we must also
 provide the function which returns information about the arguments.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>printf_size_info</b><i> (const struct printf_info *<var>info</var>, size_t <var>n</var>, int *<var>argtypes</var>)
-</i></td>
+<td align="left"><code>int <b>printf_size_info</b><i> (const struct printf_info *<var>info</var>, size_t <var>n</var>, int *<var>argtypes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function will return in <var>argtypes</var> the information about the
 used parameters in the way the <code>vfprintf</code> implementation expects
 it.  The format always takes one argument. 
@@ -25717,12 +25179,12 @@
 the preferred way to use this functionality since it is available on
 some other systems which also use format specifiers.
 
 <p><hr>
-Node:<a name="Formatted%20Input">Formatted Input</a>,
-Next:<a rel=next accesskey=n href="#EOF%20and%20Errors">EOF and Errors</a>,
-Previous:<a rel=previous accesskey=p href="#Customizing%20Printf">Customizing Printf</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Formatted Input">Formatted Input</a>,
+Next:<a rel=next accesskey=n href="#EOF and Errors">EOF and Errors</a>,
+Previous:<a rel=previous accesskey=p href="#Customizing Printf">Customizing Printf</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Formatted Input</h3>
 
@@ -25732,23 +25194,23 @@
 reading arbitrary values under the control of a <dfn>format string</dfn> or
 <dfn>template string</dfn>.
 
 <ul>
-<li><a accesskey=1 href="#Formatted%20Input%20Basics">Formatted Input Basics</a>:       Some basics to get you started. 
-<li><a accesskey=2 href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>:      Syntax of conversion specifications. 
-<li><a accesskey=3 href="#Table%20of%20Input%20Conversions">Table of Input Conversions</a>:   Summary of input conversions and what they do. 
-<li><a accesskey=4 href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>:    Details of conversions for reading numbers. 
-<li><a accesskey=5 href="#String%20Input%20Conversions">String Input Conversions</a>:     Details of conversions for reading strings. 
-<li><a accesskey=6 href="#Dynamic%20String%20Input">Dynamic String Input</a>: 	String conversions that <code>malloc</code> the buffer. 
-<li><a accesskey=7 href="#Other%20Input%20Conversions">Other Input Conversions</a>:      Details of miscellaneous other conversions. 
-<li><a accesskey=8 href="#Formatted%20Input%20Functions">Formatted Input Functions</a>:    Descriptions of the actual functions. 
-<li><a accesskey=9 href="#Variable%20Arguments%20Input">Variable Arguments Input</a>:     <code>vscanf</code> and friends. 
+<li><a accesskey=1 href="#Formatted Input Basics">Formatted Input Basics</a>:       Some basics to get you started. 
+<li><a accesskey=2 href="#Input Conversion Syntax">Input Conversion Syntax</a>:      Syntax of conversion specifications. 
+<li><a accesskey=3 href="#Table of Input Conversions">Table of Input Conversions</a>:   Summary of input conversions and what they do. 
+<li><a accesskey=4 href="#Numeric Input Conversions">Numeric Input Conversions</a>:    Details of conversions for reading numbers. 
+<li><a accesskey=5 href="#String Input Conversions">String Input Conversions</a>:     Details of conversions for reading strings. 
+<li><a accesskey=6 href="#Dynamic String Input">Dynamic String Input</a>: 	String conversions that <code>malloc</code> the buffer. 
+<li><a accesskey=7 href="#Other Input Conversions">Other Input Conversions</a>:      Details of miscellaneous other conversions. 
+<li><a accesskey=8 href="#Formatted Input Functions">Formatted Input Functions</a>:    Descriptions of the actual functions. 
+<li><a accesskey=9 href="#Variable Arguments Input">Variable Arguments Input</a>:     <code>vscanf</code> and friends. 
 </ul>
 
 <p><hr>
-Node:<a name="Formatted%20Input%20Basics">Formatted Input Basics</a>,
-Next:<a rel=next accesskey=n href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Formatted Input Basics">Formatted Input Basics</a>,
+Next:<a rel=next accesskey=n href="#Input Conversion Syntax">Input Conversion Syntax</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Formatted Input Basics</h4>
 
@@ -25804,12 +25266,12 @@
 lexical scanner, or Bison to generate a parser, rather than using
 <code>scanf</code>.  For more information about these tools, see <a href="flex.info.html#Top">Top</a>, and <a href="bison.info.html#Top">Top</a>.
 
 <p><hr>
-Node:<a name="Input%20Conversion%20Syntax">Input Conversion Syntax</a>,
-Next:<a rel=next accesskey=n href="#Table%20of%20Input%20Conversions">Table of Input Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#Formatted%20Input%20Basics">Formatted Input Basics</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Input Conversion Syntax">Input Conversion Syntax</a>,
+Next:<a rel=next accesskey=n href="#Table of Input Conversions">Table of Input Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#Formatted Input Basics">Formatted Input Basics</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Input Conversion Syntax</h4>
 
@@ -25817,9 +25279,9 @@
 multibyte characters interspersed with conversion specifications that
 start with <code>%</code>.
 
 <p>Any whitespace character (as defined by the <code>isspace</code> function;
-see <a href="#Classification%20of%20Characters">Classification of Characters</a>) in the template causes any number
+see <a href="#Classification of Characters">Classification of Characters</a>) in the template causes any number
 of whitespace characters in the input stream to be read and discarded. 
 The whitespace characters that are matched need not be exactly the same
 whitespace characters that appear in the template string.  For example,
 write <code> , </code> in the template to recognize a comma with optional
@@ -25848,9 +25310,9 @@
 
 <li>An optional flag character <code>a</code> (valid with string conversions only)
 which requests allocation of a buffer long enough to store the string in. 
 (This is a GNU extension.) 
-See <a href="#Dynamic%20String%20Input">Dynamic String Input</a>.
+See <a href="#Dynamic String Input">Dynamic String Input</a>.
 
 <li>An optional decimal integer that specifies the <dfn>maximum field
 width</dfn>.  Reading of characters from the input stream stops either when
 this maximum is reached or when a non-matching character is found,
@@ -25877,48 +25339,48 @@
 <code>scanf</code> and related functions.  It examines the format string and
 verifies that the correct number and types of arguments are supplied. 
 There is also a GNU C syntax to tell the compiler that a function you
 write uses a <code>scanf</code>-style format string. 
-See <a href="gcc.info.html#Function%20Attributes">Declaring Attributes of Functions</a>, for more information.
+See <a href="gcc.info.html#Function Attributes">Declaring Attributes of Functions</a>, for more information.
 
 <p><hr>
-Node:<a name="Table%20of%20Input%20Conversions">Table of Input Conversions</a>,
-Next:<a rel=next accesskey=n href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Table of Input Conversions">Table of Input Conversions</a>,
+Next:<a rel=next accesskey=n href="#Numeric Input Conversions">Numeric Input Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#Input Conversion Syntax">Input Conversion Syntax</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Table of Input Conversions</h4>
 
 <p>Here is a table that summarizes the various conversion specifications:
 
 <dl>
 <dt><code>%d</code>
-<dd>Matches an optionally signed integer written in decimal.  See <a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>.
+<dd>Matches an optionally signed integer written in decimal.  See <a href="#Numeric Input Conversions">Numeric Input Conversions</a>.
 
 <br><dt><code>%i</code>
 <dd>Matches an optionally signed integer in any of the formats that the C
-language defines for specifying an integer constant.  See <a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>.
+language defines for specifying an integer constant.  See <a href="#Numeric Input Conversions">Numeric Input Conversions</a>.
 
 <br><dt><code>%o</code>
 <dd>Matches an unsigned integer written in octal radix. 
-See <a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>.
+See <a href="#Numeric Input Conversions">Numeric Input Conversions</a>.
 
 <br><dt><code>%u</code>
 <dd>Matches an unsigned integer written in decimal radix. 
-See <a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>.
+See <a href="#Numeric Input Conversions">Numeric Input Conversions</a>.
 
 <br><dt><code>%x</code>, <code>%X</code>
 <dd>Matches an unsigned integer written in hexadecimal radix. 
-See <a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>.
+See <a href="#Numeric Input Conversions">Numeric Input Conversions</a>.
 
 <br><dt><code>%e</code>, <code>%f</code>, <code>%g</code>, <code>%E</code>, <code>%G</code>
-<dd>Matches an optionally signed floating-point number.  See <a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>.
+<dd>Matches an optionally signed floating-point number.  See <a href="#Numeric Input Conversions">Numeric Input Conversions</a>.
 
 <br><dt><code>%s</code>
 <dd>
 Matches a string containing only non-whitespace characters. 
-See <a href="#String%20Input%20Conversions">String Input Conversions</a>.  The presence of the <code>l</code> modifier
+See <a href="#String Input Conversions">String Input Conversions</a>.  The presence of the <code>l</code> modifier
 determines whether the output is stored as a wide character string or a
 multibyte string.  If <code>%s</code> is used in a wide character function the
 string is converted as with multiple calls to <code>wcrtomb</code> into a
 multibyte string.  This means that the buffer must provide room for
@@ -25932,9 +25394,9 @@
 with the Unix standard.
 
 <br><dt><code>%[</code>
 <dd>Matches a string of characters that belong to a specified set. 
-See <a href="#String%20Input%20Conversions">String Input Conversions</a>.  The presence of the <code>l</code> modifier
+See <a href="#String Input Conversions">String Input Conversions</a>.  The presence of the <code>l</code> modifier
 determines whether the output is stored as a wide character string or a
 multibyte string.  If <code>%[</code> is used in a wide character function the
 string is converted as with multiple calls to <code>wcrtomb</code> into a
 multibyte string.  This means that the buffer must provide room for
@@ -25945,9 +25407,9 @@
 
 <br><dt><code>%c</code>
 <dd>Matches a string of one or more characters; the number of characters
 read is controlled by the maximum field width given for the conversion. 
-See <a href="#String%20Input%20Conversions">String Input Conversions</a>.
+See <a href="#String Input Conversions">String Input Conversions</a>.
 
 <p>If the <code>%c</code> is used in a wide stream function the read value is
 converted from a wide character to the corresponding multibyte character
 before storing it.  Note that this conversion can produce more than one
@@ -25961,17 +25423,17 @@
 with the Unix standard.
 
 <br><dt><code>%p</code>
 <dd>Matches a pointer value in the same implementation-defined format used
-by the <code>%p</code> output conversion for <code>printf</code>.  See <a href="#Other%20Input%20Conversions">Other Input Conversions</a>.
+by the <code>%p</code> output conversion for <code>printf</code>.  See <a href="#Other Input Conversions">Other Input Conversions</a>.
 
 <br><dt><code>%n</code>
 <dd>This conversion doesn't read any characters; it records the number of
-characters read so far by this call.  See <a href="#Other%20Input%20Conversions">Other Input Conversions</a>.
+characters read so far by this call.  See <a href="#Other Input Conversions">Other Input Conversions</a>.
 
 <br><dt><code>%%</code>
 <dd>This matches a literal <code>%</code> character in the input stream.  No
-corresponding argument is used.  See <a href="#Other%20Input%20Conversions">Other Input Conversions</a>. 
+corresponding argument is used.  See <a href="#Other Input Conversions">Other Input Conversions</a>. 
 </dl>
 
 <p>If the syntax of a conversion specification is invalid, the behavior is
 undefined.  If there aren't enough function arguments provided to supply
@@ -25980,12 +25442,12 @@
 types, the behavior is also undefined.  On the other hand, extra
 arguments are simply ignored.
 
 <p><hr>
-Node:<a name="Numeric%20Input%20Conversions">Numeric Input Conversions</a>,
-Next:<a rel=next accesskey=n href="#String%20Input%20Conversions">String Input Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#Table%20of%20Input%20Conversions">Table of Input Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Numeric Input Conversions">Numeric Input Conversions</a>,
+Next:<a rel=next accesskey=n href="#String Input Conversions">String Input Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#Table of Input Conversions">Table of Input Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Numeric Input Conversions</h4>
 
@@ -25993,27 +25455,27 @@
 values.
 
 <p>The <code>%d</code> conversion matches an optionally signed integer in decimal
 radix.  The syntax that is recognized is the same as that for the
-<code>strtol</code> function (see <a href="#Parsing%20of%20Integers">Parsing of Integers</a>) with the value
+<code>strtol</code> function (see <a href="#Parsing of Integers">Parsing of Integers</a>) with the value
 <code>10</code> for the <var>base</var> argument.
 
 <p>The <code>%i</code> conversion matches an optionally signed integer in any of
 the formats that the C language defines for specifying an integer
 constant.  The syntax that is recognized is the same as that for the
-<code>strtol</code> function (see <a href="#Parsing%20of%20Integers">Parsing of Integers</a>) with the value
+<code>strtol</code> function (see <a href="#Parsing of Integers">Parsing of Integers</a>) with the value
 <code>0</code> for the <var>base</var> argument.  (You can print integers in this
 syntax with <code>printf</code> by using the <code>#</code> flag character with the
-<code>%x</code>, <code>%o</code>, or <code>%d</code> conversion.  See <a href="#Integer%20Conversions">Integer Conversions</a>.)
+<code>%x</code>, <code>%o</code>, or <code>%d</code> conversion.  See <a href="#Integer Conversions">Integer Conversions</a>.)
 
 <p>For example, any of the strings <code>10</code>, <code>0xa</code>, or <code>012</code>
 could be read in as integers under the <code>%i</code> conversion.  Each of
 these specifies a number with decimal value <code>10</code>.
 
 <p>The <code>%o</code>, <code>%u</code>, and <code>%x</code> conversions match unsigned
 integers in octal, decimal, and hexadecimal radices, respectively.  The
 syntax that is recognized is the same as that for the <code>strtoul</code>
-function (see <a href="#Parsing%20of%20Integers">Parsing of Integers</a>) with the appropriate value
+function (see <a href="#Parsing of Integers">Parsing of Integers</a>) with the appropriate value
 (<code>8</code>, <code>10</code>, or <code>16</code>) for the <var>base</var> argument.
 
 <p>The <code>%X</code> conversion is identical to the <code>%x</code> conversion.  They
 both permit either uppercase or lowercase letters to be used as digits.
@@ -26072,9 +25534,9 @@
 
 <p>All of the <code>%e</code>, <code>%f</code>, <code>%g</code>, <code>%E</code>, and <code>%G</code>
 input conversions are interchangeable.  They all match an optionally
 signed floating point number, in the same syntax as for the
-<code>strtod</code> function (see <a href="#Parsing%20of%20Floats">Parsing of Floats</a>).
+<code>strtod</code> function (see <a href="#Parsing of Floats">Parsing of Floats</a>).
 
 <p>For the floating-point input conversions, the default argument type is
 <code>float *</code>.  (This is different from the corresponding output
 conversions, where the default type is <code>double</code>; remember that
@@ -26094,20 +25556,20 @@
 <p>For all the above number parsing formats there is an additional optional
 flag <code>'</code>.  When this flag is given the <code>scanf</code> function
 expects the number represented in the input string to be formatted
 according to the grouping rules of the currently selected locale
-(see <a href="#General%20Numeric">General Numeric</a>).
+(see <a href="#General Numeric">General Numeric</a>).
 
 <p>If the <code>"C"</code> or <code>"POSIX"</code> locale is selected there is no
 difference.  But for a locale which specifies values for the appropriate
 fields in the locale the input must have the correct form in the input. 
 Otherwise the longest prefix with a correct form is processed.
 
 <p><hr>
-Node:<a name="String%20Input%20Conversions">String Input Conversions</a>,
-Next:<a rel=next accesskey=n href="#Dynamic%20String%20Input">Dynamic String Input</a>,
-Previous:<a rel=previous accesskey=p href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="String Input Conversions">String Input Conversions</a>,
+Next:<a rel=next accesskey=n href="#Dynamic String Input">Dynamic String Input</a>,
+Previous:<a rel=previous accesskey=p href="#Numeric Input Conversions">Numeric Input Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>String Input Conversions</h4>
 
@@ -26132,9 +25594,9 @@
 
 <li>Ask <code>scanf</code> to allocate a big enough buffer, by specifying the
 <code>a</code> flag character.  This is a GNU extension.  You should provide
 an argument of type <code>char **</code> for the buffer address to be stored
-in.  See <a href="#Dynamic%20String%20Input">Dynamic String Input</a>. 
+in.  See <a href="#Dynamic String Input">Dynamic String Input</a>. 
 </ul>
 
 <p>The <code>%c</code> conversion is the simplest: it matches a fixed number of
 characters, always.  The maximum field width says how many characters to
@@ -26230,12 +25692,12 @@
 supply input that is longer.  A well-written program reports invalid
 input with a comprehensible error message, not with a crash.
 
 <p><hr>
-Node:<a name="Dynamic%20String%20Input">Dynamic String Input</a>,
-Next:<a rel=next accesskey=n href="#Other%20Input%20Conversions">Other Input Conversions</a>,
-Previous:<a rel=previous accesskey=p href="#String%20Input%20Conversions">String Input Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Dynamic String Input">Dynamic String Input</a>,
+Next:<a rel=next accesskey=n href="#Other Input Conversions">Other Input Conversions</a>,
+Previous:<a rel=previous accesskey=p href="#String Input Conversions">String Input Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Dynamically Allocating String Conversions</h4>
 
@@ -26268,21 +25730,21 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Other%20Input%20Conversions">Other Input Conversions</a>,
-Next:<a rel=next accesskey=n href="#Formatted%20Input%20Functions">Formatted Input Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Dynamic%20String%20Input">Dynamic String Input</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Other Input Conversions">Other Input Conversions</a>,
+Next:<a rel=next accesskey=n href="#Formatted Input Functions">Formatted Input Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Dynamic String Input">Dynamic String Input</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Other Input Conversions</h4>
 
 <p>This section describes the miscellaneous input conversions.
 
 <p>The <code>%p</code> conversion is used to read a pointer value.  It recognizes
 the same syntax used by the <code>%p</code> output conversion for
-<code>printf</code> (see <a href="#Other%20Output%20Conversions">Other Output Conversions</a>); that is, a hexadecimal
+<code>printf</code> (see <a href="#Other Output Conversions">Other Output Conversions</a>); that is, a hexadecimal
 number just as the <code>%x</code> conversion accepts.  The corresponding
 argument should be of type <code>void **</code>; that is, the address of a
 place to store a pointer.
 
@@ -26291,9 +25753,9 @@
 
 <p>The <code>%n</code> conversion produces the number of characters read so far
 by this call.  The corresponding argument should be of type <code>int *</code>. 
 This conversion works in the same way as the <code>%n</code> conversion for
-<code>printf</code>; see <a href="#Other%20Output%20Conversions">Other Output Conversions</a>, for an example.
+<code>printf</code>; see <a href="#Other Output Conversions">Other Output Conversions</a>, for an example.
 
 <p>The <code>%n</code> conversion is the only mechanism for determining the
 success of literal matches or conversions with suppressed assignments. 
 If the <code>%n</code> follows the locus of a matching failure, then no value
@@ -26306,12 +25768,12 @@
 in the input stream, without using an argument.  This conversion does
 not permit any flags, field width, or type modifier to be specified.
 
 <p><hr>
-Node:<a name="Formatted%20Input%20Functions">Formatted Input Functions</a>,
-Next:<a rel=next accesskey=n href="#Variable%20Arguments%20Input">Variable Arguments Input</a>,
-Previous:<a rel=previous accesskey=p href="#Other%20Input%20Conversions">Other Input Conversions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Formatted Input Functions">Formatted Input Functions</a>,
+Next:<a rel=next accesskey=n href="#Variable Arguments Input">Variable Arguments Input</a>,
+Previous:<a rel=previous accesskey=p href="#Other Input Conversions">Other Input Conversions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Formatted Input Functions</h4>
 
@@ -26319,16 +25781,15 @@
 input. 
 Prototypes for these functions are in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>scanf</b><i> (const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>scanf</b><i> (const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>scanf</code> function reads formatted input from the stream
 <code>stdin</code> under the control of the template string <var>template</var>. 
 The optional arguments are pointers to the places which receive the
@@ -26341,16 +25802,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>wscanf</b><i> (const wchar_t *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>wscanf</b><i> (const wchar_t *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wscanf</code> function reads formatted input from the stream
 <code>stdin</code> under the control of the template string <var>template</var>. 
 The optional arguments are pointers to the places which receive the
@@ -26363,46 +25823,43 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fscanf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>fscanf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is just like <code>scanf</code>, except that the input is read
 from the stream <var>stream</var> instead of <code>stdin</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fwscanf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>fwscanf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is just like <code>wscanf</code>, except that the input is read
 from the stream <var>stream</var> instead of <code>stdin</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sscanf</b><i> (const char *<var>s</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>sscanf</b><i> (const char *<var>s</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>scanf</code>, except that the characters are taken from the
 null-terminated string <var>s</var> instead of from a stream.  Reaching the
 end of the string is treated as an end-of-file condition.
@@ -26414,16 +25871,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>swscanf</b><i> (const wchar_t *<var>ws</var>, const char *<var>template</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>swscanf</b><i> (const wchar_t *<var>ws</var>, const char *<var>template</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>wscanf</code>, except that the characters are taken from the
 null-terminated string <var>ws</var> instead of from a stream.  Reaching the
 end of the string is treated as an end-of-file condition.
@@ -26435,111 +25891,105 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Variable%20Arguments%20Input">Variable Arguments Input</a>,
-Previous:<a rel=previous accesskey=p href="#Formatted%20Input%20Functions">Formatted Input Functions</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Input">Formatted Input</a>
+Node:<a name="Variable Arguments Input">Variable Arguments Input</a>,
+Previous:<a rel=previous accesskey=p href="#Formatted Input Functions">Formatted Input Functions</a>,
+Up:<a rel=up accesskey=u href="#Formatted Input">Formatted Input</a>
 <br>
 
 <h4>Variable Arguments Input Functions</h4>
 
 <p>The functions <code>vscanf</code> and friends are provided so that you can
 define your own variadic <code>scanf</code>-like functions that make use of
 the same internals as the built-in formatted output functions. 
 These functions are analogous to the <code>vprintf</code> series of output
-functions.  See <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>, for important
+functions.  See <a href="#Variable Arguments Output">Variable Arguments Output</a>, for important
 information on how to use them.
 
 <p><strong>Portability Note:</strong> The functions listed in this section were
 introduced in ISO&nbsp;C99 and were before available as GNU extensions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vscanf</b><i> (const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vscanf</b><i> (const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>scanf</code>, but instead of taking
 a variable number of arguments directly, it takes an argument list
-pointer <var>ap</var> of type <code>va_list</code> (see <a href="#Variadic%20Functions">Variadic Functions</a>). 
+pointer <var>ap</var> of type <code>va_list</code> (see <a href="#Variadic Functions">Variadic Functions</a>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vwscanf</b><i> (const wchar_t *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vwscanf</b><i> (const wchar_t *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>wscanf</code>, but instead of taking
 a variable number of arguments directly, it takes an argument list
-pointer <var>ap</var> of type <code>va_list</code> (see <a href="#Variadic%20Functions">Variadic Functions</a>). 
+pointer <var>ap</var> of type <code>va_list</code> (see <a href="#Variadic Functions">Variadic Functions</a>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vfscanf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vfscanf</b><i> (FILE *<var>stream</var>, const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>fscanf</code> with the variable argument list
 specified directly as for <code>vscanf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vfwscanf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vfwscanf</b><i> (FILE *<var>stream</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>fwscanf</code> with the variable argument list
 specified directly as for <code>vwscanf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vsscanf</b><i> (const char *<var>s</var>, const char *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vsscanf</b><i> (const char *<var>s</var>, const char *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>sscanf</code> with the variable argument list
 specified directly as for <code>vscanf</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vswscanf</b><i> (const wchar_t *<var>s</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>int <b>vswscanf</b><i> (const wchar_t *<var>s</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the equivalent of <code>swscanf</code> with the variable argument list
 specified directly as for <code>vwscanf</code>. 
 </td></tr>
@@ -26548,15 +25998,15 @@
 <p>In GNU C, there is a special construct you can use to let the compiler
 know that a function uses a <code>scanf</code>-style format string.  Then it
 can check the number and types of arguments in each call to the
 function, and warn you when they do not match the format string. 
-For details, See <a href="gcc.info.html#Function%20Attributes">Declaring Attributes of Functions</a>.
+For details, See <a href="gcc.info.html#Function Attributes">Declaring Attributes of Functions</a>.
 
 <p><hr>
-Node:<a name="EOF%20and%20Errors">EOF and Errors</a>,
-Next:<a rel=next accesskey=n href="#Error%20Recovery">Error Recovery</a>,
-Previous:<a rel=previous accesskey=p href="#Formatted%20Input">Formatted Input</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="EOF and Errors">EOF and Errors</a>,
+Next:<a rel=next accesskey=n href="#Error Recovery">Error Recovery</a>,
+Previous:<a rel=previous accesskey=p href="#Formatted Input">Formatted Input</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>End-Of-File and Errors</h3>
 
@@ -26569,16 +26019,15 @@
 object, indicators set if the appropriate condition was detected by a
 previous I/O operation on that stream.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EOF</b><i>
-</i></td>
+<td align="left"><code>int <b>EOF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is an integer value that is returned by a number of narrow
 stream functions to indicate an end-of-file condition, or some other
 error situation.  With the GNU library, <code>EOF</code> is <code>-1</code>.  In
@@ -26588,16 +26037,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WEOF</b><i>
-</i></td>
+<td align="left"><code>int <b>WEOF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is an integer value that is returned by a number of wide
 stream functions to indicate an end-of-file condition, or some other
 error situation.  With the GNU library, <code>WEOF</code> is <code>-1</code>.  In
@@ -26607,16 +26055,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>feof</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>feof</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>feof</code> function returns nonzero if and only if the end-of-file
 indicator for the stream <var>stream</var> is set.
 
@@ -26624,16 +26071,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>feof_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>feof_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>feof_unlocked</code> function is equivalent to the <code>feof</code>
 function except that it does not implicitly lock the stream.
 
@@ -26643,16 +26089,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ferror</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>ferror</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ferror</code> function returns nonzero if and only if the error
 indicator for the stream <var>stream</var> is set, indicating that an error
 has occurred on a previous operation on the stream.
@@ -26661,16 +26106,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ferror_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>ferror_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ferror_unlocked</code> function is equivalent to the <code>ferror</code>
 function except that it does not implicitly lock the stream.
 
@@ -26687,49 +26131,47 @@
 stream--such as <code>fputc</code>, <code>printf</code>, and <code>fflush</code>--are
 implemented in terms of <code>write</code>, and all of the <code>errno</code> error
 conditions defined for <code>write</code> are meaningful for these functions. 
 For more information about the descriptor-level I/O functions, see
-<a href="#Low-Level%20I%2fO">Low-Level I/O</a>.
+<a href="#Low-Level I%2fO">Low-Level I/O</a>.
 
 <p><hr>
-Node:<a name="Error%20Recovery">Error Recovery</a>,
-Next:<a rel=next accesskey=n href="#Binary%20Streams">Binary Streams</a>,
-Previous:<a rel=previous accesskey=p href="#EOF%20and%20Errors">EOF and Errors</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Error Recovery">Error Recovery</a>,
+Next:<a rel=next accesskey=n href="#Binary Streams">Binary Streams</a>,
+Previous:<a rel=previous accesskey=p href="#EOF and Errors">EOF and Errors</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Recovering from errors</h3>
 
 <p>You may explicitly clear the error and EOF flags with the <code>clearerr</code>
 function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>clearerr</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>void <b>clearerr</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function clears the end-of-file and error indicators for the
 stream <var>stream</var>.
 
-<p>The file positioning functions (see <a href="#File%20Positioning">File Positioning</a>) also clear the
+<p>The file positioning functions (see <a href="#File Positioning">File Positioning</a>) also clear the
 end-of-file indicator for the stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>clearerr_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>void <b>clearerr_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>clearerr_unlocked</code> function is equivalent to the <code>clearerr</code>
 function except that it does not implicitly lock the stream.
 
@@ -26751,21 +26193,21 @@
 always fail again in the same way.  So usually it is best to give up and
 report the error to the user, rather than install complicated recovery
 logic.
 
-<p>One important exception is <code>EINTR</code> (see <a href="#Interrupted%20Primitives">Interrupted Primitives</a>). 
+<p>One important exception is <code>EINTR</code> (see <a href="#Interrupted Primitives">Interrupted Primitives</a>). 
 Many stream I/O implementations will treat it as an ordinary error, which
 can be quite inconvenient.  You can avoid this hassle by installing all
 signals with the <code>SA_RESTART</code> flag.
 
 <p>For similar reasons, setting nonblocking I/O on a stream's file
 descriptor is not usually advisable.
 
 <p><hr>
-Node:<a name="Binary%20Streams">Binary Streams</a>,
-Next:<a rel=next accesskey=n href="#File%20Positioning">File Positioning</a>,
-Previous:<a rel=previous accesskey=p href="#Error%20Recovery">Error Recovery</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Binary Streams">Binary Streams</a>,
+Next:<a rel=next accesskey=n href="#File Positioning">File Positioning</a>,
+Previous:<a rel=previous accesskey=p href="#Error Recovery">Error Recovery</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Text and Binary Streams</h3>
 
@@ -26778,9 +26220,9 @@
 
 <p>When you open a stream, you can specify either a <dfn>text stream</dfn> or a
 <dfn>binary stream</dfn>.  You indicate that you want a binary stream by
 specifying the <code>b</code> modifier in the <var>opentype</var> argument to
-<code>fopen</code>; see <a href="#Opening%20Streams">Opening Streams</a>.  Without this
+<code>fopen</code>; see <a href="#Opening Streams">Opening Streams</a>.  Without this
 option, <code>fopen</code> opens the file as a text stream.
 
 <p>Text and binary streams differ in several ways:
 
@@ -26817,21 +26259,21 @@
 This stream can handle any file content, and has none of the
 restrictions that text streams sometimes have.
 
 <p><hr>
-Node:<a name="File%20Positioning">File Positioning</a>,
-Next:<a rel=next accesskey=n href="#Portable%20Positioning">Portable Positioning</a>,
-Previous:<a rel=previous accesskey=p href="#Binary%20Streams">Binary Streams</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="File Positioning">File Positioning</a>,
+Next:<a rel=next accesskey=n href="#Portable Positioning">Portable Positioning</a>,
+Previous:<a rel=previous accesskey=p href="#Binary Streams">Binary Streams</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>File Positioning</h3>
 
 <p>The <dfn>file position</dfn> of a stream describes where in the file the
 stream is currently reading or writing.  I/O on the stream advances the
 file position through the file.  In the GNU system, the file position is
 represented as an integer, which counts the number of bytes from the
-beginning of the file.  See <a href="#File%20Position">File Position</a>.
+beginning of the file.  See <a href="#File Position">File Position</a>.
 
 <p>During I/O to an ordinary disk file, you can change the file position
 whenever you wish, so as to read or write any portion of the file.  Some
 other kinds of files may also permit this.  Files which support changing
@@ -26842,16 +26284,15 @@
 position indicator associated with a stream.  The symbols listed below
 are declared in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>ftell</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>long int <b>ftell</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the current file position of the stream
 <var>stream</var>.
 
@@ -26862,16 +26303,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">off_t <b>ftello</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>off_t <b>ftello</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ftello</code> function is similar to <code>ftell</code>, except that it
 returns a value of type <code>off_t</code>.  Systems which support this type
 use it to describe all file positions, unlike the POSIX specification
@@ -26893,16 +26333,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">off64_t <b>ftello64</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>off64_t <b>ftello64</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>ftello</code> with the only difference that
 the return value is of type <code>off64_t</code>.  This also requires that the
 stream <var>stream</var> was opened using either <code>fopen64</code>,
@@ -26916,16 +26355,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fseek</b><i> (FILE *<var>stream</var>, long int <var>offset</var>, int <var>whence</var>)
-</i></td>
+<td align="left"><code>int <b>fseek</b><i> (FILE *<var>stream</var>, long int <var>offset</var>, int <var>whence</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fseek</code> function is used to change the file position of the
 stream <var>stream</var>.  The value of <var>whence</var> must be one of the
 constants <code>SEEK_SET</code>, <code>SEEK_CUR</code>, or <code>SEEK_END</code>, to
@@ -26943,16 +26381,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fseeko</b><i> (FILE *<var>stream</var>, off_t <var>offset</var>, int <var>whence</var>)
-</i></td>
+<td align="left"><code>int <b>fseeko</b><i> (FILE *<var>stream</var>, off_t <var>offset</var>, int <var>whence</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fseek</code> but it corrects a problem with
 <code>fseek</code> in a system with POSIX types.  Using a value of type
 <code>long int</code> for the offset is not compatible with POSIX. 
@@ -26974,16 +26411,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fseeko64</b><i> (FILE *<var>stream</var>, off64_t <var>offset</var>, int <var>whence</var>)
-</i></td>
+<td align="left"><code>int <b>fseeko64</b><i> (FILE *<var>stream</var>, off64_t <var>offset</var>, int <var>whence</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fseeko</code> with the only difference that
 the <var>offset</var> parameter is of type <code>off64_t</code>.  This also
 requires that the stream <var>stream</var> was opened using either
@@ -26998,72 +26434,68 @@
 </table>
 
 <p><strong>Portability Note:</strong> In non-POSIX systems, <code>ftell</code>,
 <code>ftello</code>, <code>fseek</code> and <code>fseeko</code> might work reliably only
-on binary streams.  See <a href="#Binary%20Streams">Binary Streams</a>.
+on binary streams.  See <a href="#Binary Streams">Binary Streams</a>.
 
 <p>The following symbolic constants are defined for use as the <var>whence</var>
 argument to <code>fseek</code>.  They are also used with the <code>lseek</code>
-function (see <a href="#I%2fO%20Primitives">I/O Primitives</a>) and to specify offsets for file locks
-(see <a href="#Control%20Operations">Control Operations</a>).
+function (see <a href="#I%2fO Primitives">I/O Primitives</a>) and to specify offsets for file locks
+(see <a href="#Control Operations">Control Operations</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SEEK_SET</b><i>
-</i></td>
+<td align="left"><code>int <b>SEEK_SET</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an integer constant which, when used as the <var>whence</var>
 argument to the <code>fseek</code> or <code>fseeko</code> function, specifies that
 the offset provided is relative to the beginning of the file. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SEEK_CUR</b><i>
-</i></td>
+<td align="left"><code>int <b>SEEK_CUR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an integer constant which, when used as the <var>whence</var>
 argument to the <code>fseek</code> or <code>fseeko</code> function, specifies that
 the offset provided is relative to the current file position. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SEEK_END</b><i>
-</i></td>
+<td align="left"><code>int <b>SEEK_END</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an integer constant which, when used as the <var>whence</var>
 argument to the <code>fseek</code> or <code>fseeko</code> function, specifies that
 the offset provided is relative to the end of the file. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>rewind</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>void <b>rewind</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>rewind</code> function positions the stream <var>stream</var> at the
 beginning of the file.  It is equivalent to calling <code>fseek</code> or
 <code>fseeko</code> on the <var>stream</var> with an <var>offset</var> argument of
@@ -27088,12 +26520,12 @@
 <dd>An alias for <code>SEEK_END</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Portable%20Positioning">Portable Positioning</a>,
-Next:<a rel=next accesskey=n href="#Stream%20Buffering">Stream Buffering</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Positioning">File Positioning</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Portable Positioning">Portable Positioning</a>,
+Next:<a rel=next accesskey=n href="#Stream Buffering">Stream Buffering</a>,
+Previous:<a rel=previous accesskey=p href="#File Positioning">File Positioning</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Portable File-Position Functions</h3>
 
@@ -27146,16 +26578,15 @@
 
 <p>These symbols are declared in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>fpos_t</b><i>
-</i></td>
+<td align="left"><code><b>fpos_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the type of an object that can encode information about the
 file position of a stream, for use by the functions <code>fgetpos</code> and
 <code>fsetpos</code>.
@@ -27171,16 +26602,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>fpos64_t</b><i>
-</i></td>
+<td align="left"><code><b>fpos64_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the type of an object that can encode information about the
 file position of a stream, for use by the functions <code>fgetpos64</code> and
 <code>fsetpos64</code>.
@@ -27192,16 +26622,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fgetpos</b><i> (FILE *<var>stream</var>, fpos_t *<var>position</var>)
-</i></td>
+<td align="left"><code>int <b>fgetpos</b><i> (FILE *<var>stream</var>, fpos_t *<var>position</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function stores the value of the file position indicator for the
 stream <var>stream</var> in the <code>fpos_t</code> object pointed to by
 <var>position</var>.  If successful, <code>fgetpos</code> returns zero; otherwise
@@ -27214,16 +26643,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fgetpos64</b><i> (FILE *<var>stream</var>, fpos64_t *<var>position</var>)
-</i></td>
+<td align="left"><code>int <b>fgetpos64</b><i> (FILE *<var>stream</var>, fpos64_t *<var>position</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fgetpos</code> but the file position is
 returned in a variable of type <code>fpos64_t</code> to which <var>position</var>
 points.
@@ -27234,16 +26662,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fsetpos</b><i> (FILE *<var>stream</var>, const fpos_t *<var>position</var>)
-</i></td>
+<td align="left"><code>int <b>fsetpos</b><i> (FILE *<var>stream</var>, const fpos_t *<var>position</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the file position indicator for the stream <var>stream</var>
 to the position <var>position</var>, which must have been set by a previous
 call to <code>fgetpos</code> on the same stream.  If successful, <code>fsetpos</code>
@@ -27258,16 +26685,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fsetpos64</b><i> (FILE *<var>stream</var>, const fpos64_t *<var>position</var>)
-</i></td>
+<td align="left"><code>int <b>fsetpos64</b><i> (FILE *<var>stream</var>, const fpos64_t *<var>position</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fsetpos</code> but the file position used
 for positioning is provided in a variable of type <code>fpos64_t</code> to
 which <var>position</var> points.
@@ -27278,12 +26704,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Stream%20Buffering">Stream Buffering</a>,
-Next:<a rel=next accesskey=n href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>,
-Previous:<a rel=previous accesskey=p href="#Portable%20Positioning">Portable Positioning</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Stream Buffering">Stream Buffering</a>,
+Next:<a rel=next accesskey=n href="#Other Kinds of Streams">Other Kinds of Streams</a>,
+Previous:<a rel=previous accesskey=p href="#Portable Positioning">Portable Positioning</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Stream Buffering</h3>
 
@@ -27302,24 +26728,24 @@
 <p>This section deals only with controlling when characters are transmitted
 between the stream and the file or device, and <em>not</em> with how
 things like echoing, flow control, and the like are handled on specific
 classes of devices.  For information on common control operations on
-terminal devices, see <a href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>.
+terminal devices, see <a href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>.
 
 <p>You can bypass the stream buffering facilities altogether by using the
 low-level input and output functions that operate on file descriptors
-instead.  See <a href="#Low-Level%20I%2fO">Low-Level I/O</a>.
+instead.  See <a href="#Low-Level I%2fO">Low-Level I/O</a>.
 
 <ul>
-<li><a accesskey=1 href="#Buffering%20Concepts">Buffering Concepts</a>:           Terminology is defined here. 
-<li><a accesskey=2 href="#Flushing%20Buffers">Flushing Buffers</a>:             How to ensure that output buffers are flushed. 
-<li><a accesskey=3 href="#Controlling%20Buffering">Controlling Buffering</a>:        How to specify what kind of buffering to use. 
+<li><a accesskey=1 href="#Buffering Concepts">Buffering Concepts</a>:           Terminology is defined here. 
+<li><a accesskey=2 href="#Flushing Buffers">Flushing Buffers</a>:             How to ensure that output buffers are flushed. 
+<li><a accesskey=3 href="#Controlling Buffering">Controlling Buffering</a>:        How to specify what kind of buffering to use. 
 </ul>
 
 <p><hr>
-Node:<a name="Buffering%20Concepts">Buffering Concepts</a>,
-Next:<a rel=next accesskey=n href="#Flushing%20Buffers">Flushing Buffers</a>,
-Up:<a rel=up accesskey=u href="#Stream%20Buffering">Stream Buffering</a>
+Node:<a name="Buffering Concepts">Buffering Concepts</a>,
+Next:<a rel=next accesskey=n href="#Flushing Buffers">Flushing Buffers</a>,
+Up:<a rel=up accesskey=u href="#Stream Buffering">Stream Buffering</a>
 <br>
 
 <h4>Buffering Concepts</h4>
 
@@ -27337,9 +26763,9 @@
 </ul>
 
 <p>Newly opened streams are normally fully buffered, with one exception: a
 stream connected to an interactive device such as a terminal is
-initially line buffered.  See <a href="#Controlling%20Buffering">Controlling Buffering</a>, for information
+initially line buffered.  See <a href="#Controlling Buffering">Controlling Buffering</a>, for information
 on how to select a different kind of buffering.  Usually the automatic
 selection gives you the most convenient kind of buffering for the file
 or device you open.
 
@@ -27347,15 +26773,15 @@
 messages ending in a newline will appear immediately--which is usually
 what you want.  Output that doesn't end in a newline might or might not
 show up immediately, so if you want them to appear immediately, you
 should flush buffered output explicitly with <code>fflush</code>, as described
-in <a href="#Flushing%20Buffers">Flushing Buffers</a>.
+in <a href="#Flushing Buffers">Flushing Buffers</a>.
 
 <p><hr>
-Node:<a name="Flushing%20Buffers">Flushing Buffers</a>,
-Next:<a rel=next accesskey=n href="#Controlling%20Buffering">Controlling Buffering</a>,
-Previous:<a rel=previous accesskey=p href="#Buffering%20Concepts">Buffering Concepts</a>,
-Up:<a rel=up accesskey=u href="#Stream%20Buffering">Stream Buffering</a>
+Node:<a name="Flushing Buffers">Flushing Buffers</a>,
+Next:<a rel=next accesskey=n href="#Controlling Buffering">Controlling Buffering</a>,
+Previous:<a rel=previous accesskey=p href="#Buffering Concepts">Buffering Concepts</a>,
+Up:<a rel=up accesskey=u href="#Stream Buffering">Stream Buffering</a>
 <br>
 
 <h4>Flushing Buffers</h4>
 
@@ -27365,12 +26791,12 @@
 
 <ul>
 <li>When you try to do output and the output buffer is full.
 
-<li>When the stream is closed.  See <a href="#Closing%20Streams">Closing Streams</a>.
+<li>When the stream is closed.  See <a href="#Closing Streams">Closing Streams</a>.
 
 <li>When the program terminates by calling <code>exit</code>. 
-See <a href="#Normal%20Termination">Normal Termination</a>.
+See <a href="#Normal Termination">Normal Termination</a>.
 
 <li>When a newline is written, if the stream is line buffered.
 
 <li>Whenever an input operation on <em>any</em> stream actually reads data
@@ -27380,16 +26806,15 @@
 <p>If you want to flush the buffered output at another time, call
 <code>fflush</code>, which is declared in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fflush</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fflush</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function causes any buffered output on <var>stream</var> to be delivered
 to the file.  If <var>stream</var> is a null pointer, then
 <code>fflush</code> causes buffered output on <em>all</em> open output streams
@@ -27400,16 +26825,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fflush_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fflush_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fflush_unlocked</code> function is equivalent to the <code>fflush</code>
 function except that it does not implicitly lock the stream. 
 </td></tr>
@@ -27424,16 +26848,15 @@
 always available in the GNU C library in some form but never officially
 exported.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>_flushlbf</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>_flushlbf</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>_flushlbf</code> function flushes all line buffered streams
 currently opened.
 
@@ -27453,16 +26876,15 @@
 situation a non-standard function introduced in Solaris and available in
 the GNU C library can be used.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>__fpurge</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>void <b>__fpurge</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__fpurge</code> function causes the buffer of the stream
 <var>stream</var> to be emptied.  If the stream is currently in read mode all
 input in the buffer is lost.  If the stream is in output mode the
@@ -27473,11 +26895,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Controlling%20Buffering">Controlling Buffering</a>,
-Previous:<a rel=previous accesskey=p href="#Flushing%20Buffers">Flushing Buffers</a>,
-Up:<a rel=up accesskey=u href="#Stream%20Buffering">Stream Buffering</a>
+Node:<a name="Controlling Buffering">Controlling Buffering</a>,
+Previous:<a rel=previous accesskey=p href="#Flushing Buffers">Flushing Buffers</a>,
+Up:<a rel=up accesskey=u href="#Stream Buffering">Stream Buffering</a>
 <br>
 
 <h4>Controlling Which Kind of Buffering</h4>
 
@@ -27488,16 +26910,15 @@
 <p>The facilities listed in this section are declared in the header
 file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setvbuf</b><i> (FILE *<var>stream</var>, char *<var>buf</var>, int <var>mode</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>setvbuf</b><i> (FILE *<var>stream</var>, char *<var>buf</var>, int <var>mode</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to specify that the stream <var>stream</var> should
 have the buffering mode <var>mode</var>, which can be either <code>_IOFBF</code>
 (for full buffering), <code>_IOLBF</code> (for line buffering), or
@@ -27510,9 +26931,9 @@
 <p>Otherwise, <var>buf</var> should be a character array that can hold at least
 <var>size</var> characters.  You should not free the space for this array as
 long as the stream remains open and this array remains its buffer.  You
 should usually either allocate it statically, or <code>malloc</code>
-(see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>) the buffer.  Using an automatic array
+(see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>) the buffer.  Using an automatic array
 is not a good idea unless you close the file before exiting the block
 that declares the array.
 
 <p>While the array remains a stream buffer, the stream I/O functions will
@@ -27526,64 +26947,60 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_IOFBF</b><i>
-</i></td>
+<td align="left"><code>int <b>_IOFBF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that can be
 used as the <var>mode</var> argument to the <code>setvbuf</code> function to
 specify that the stream should be fully buffered. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_IOLBF</b><i>
-</i></td>
+<td align="left"><code>int <b>_IOLBF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that can be
 used as the <var>mode</var> argument to the <code>setvbuf</code> function to
 specify that the stream should be line buffered. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_IONBF</b><i>
-</i></td>
+<td align="left"><code>int <b>_IONBF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that can be
 used as the <var>mode</var> argument to the <code>setvbuf</code> function to
 specify that the stream should be unbuffered. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>BUFSIZ</b><i>
-</i></td>
+<td align="left"><code>int <b>BUFSIZ</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that is good
 to use for the <var>size</var> argument to <code>setvbuf</code>.  This value is
 guaranteed to be at least <code>256</code>.
@@ -27593,28 +27010,27 @@
 for the buffer when you call <code>setvbuf</code>.
 
 <p>Actually, you can get an even better value to use for the buffer size
 by means of the <code>fstat</code> system call: it is found in the
-<code>st_blksize</code> field of the file attributes.  See <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>st_blksize</code> field of the file attributes.  See <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <p>Sometimes people also use <code>BUFSIZ</code> as the allocation size of
 buffers used for related purposes, such as strings used to receive a
-line of input with <code>fgets</code> (see <a href="#Character%20Input">Character Input</a>).  There is no
+line of input with <code>fgets</code> (see <a href="#Character Input">Character Input</a>).  There is no
 particular reason to use <code>BUFSIZ</code> for this instead of any other
 integer, except that it might lead to doing I/O in chunks of an
 efficient size. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setbuf</b><i> (FILE *<var>stream</var>, char *<var>buf</var>)
-</i></td>
+<td align="left"><code>void <b>setbuf</b><i> (FILE *<var>stream</var>, char *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>buf</var> is a null pointer, the effect of this function is
 equivalent to calling <code>setvbuf</code> with a <var>mode</var> argument of
 <code>_IONBF</code>.  Otherwise, it is equivalent to calling <code>setvbuf</code>
@@ -27626,16 +27042,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setbuffer</b><i> (FILE *<var>stream</var>, char *<var>buf</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void <b>setbuffer</b><i> (FILE *<var>stream</var>, char *<var>buf</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>buf</var> is a null pointer, this function makes <var>stream</var> unbuffered. 
 Otherwise, it makes <var>stream</var> fully buffered using <var>buf</var> as the
 buffer.  The <var>size</var> argument specifies the length of <var>buf</var>.
@@ -27645,16 +27060,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setlinebuf</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>void <b>setlinebuf</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function makes <var>stream</var> be line buffered, and allocates the
 buffer for you.
 
@@ -27667,16 +27081,15 @@
 using a non-standard function introduced in Solaris and available in the
 GNU C library.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>__flbf</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>__flbf</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__flbf</code> function will return a nonzero value in case the
 stream <var>stream</var> is line buffered.  Otherwise the return value is
 zero.
@@ -27688,16 +27101,15 @@
 <p>Two more extensions allow to determine the size of the buffer and how
 much of it is used.  These functions were also introduced in Solaris.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>__fbufsize</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>size_t <b>__fbufsize</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__fbufsize</code> function return the size of the buffer in the
 stream <var>stream</var>.  This value can be used to optimize the use of the
 stream.
@@ -27706,16 +27118,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>__fpending</b><i> (FILE *<var>stream</var>) The <code>__fpending</code>
-</i></td>
+<td align="left"><code>size_t <b>__fpending</b><i> (FILE *<var>stream</var>) The <code>__fpending</code></i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 function returns the number of bytes currently in the output buffer. 
 For wide-oriented stream the measuring unit is wide characters.  This
 function should not be used on buffers in read mode or opened read-only.
@@ -27724,12 +27135,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>,
-Next:<a rel=next accesskey=n href="#Formatted%20Messages">Formatted Messages</a>,
-Previous:<a rel=previous accesskey=p href="#Stream%20Buffering">Stream Buffering</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Other Kinds of Streams">Other Kinds of Streams</a>,
+Next:<a rel=next accesskey=n href="#Formatted Messages">Formatted Messages</a>,
+Previous:<a rel=previous accesskey=p href="#Stream Buffering">Stream Buffering</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Other Kinds of Streams</h3>
 
@@ -27738,30 +27149,30 @@
 
 <p>One such type of stream takes input from or writes output to a string. 
 These kinds of streams are used internally to implement the
 <code>sprintf</code> and <code>sscanf</code> functions.  You can also create such a
-stream explicitly, using the functions described in <a href="#String%20Streams">String Streams</a>.
+stream explicitly, using the functions described in <a href="#String Streams">String Streams</a>.
 
 <p>More generally, you can define streams that do input/output to arbitrary
 objects using functions supplied by your program.  This protocol is
-discussed in <a href="#Custom%20Streams">Custom Streams</a>.
+discussed in <a href="#Custom Streams">Custom Streams</a>.
 
 <p><strong>Portability Note:</strong> The facilities described in this section are
 specific to GNU.  Other systems or C implementations might or might not
 provide equivalent functionality.
 
 <ul>
-<li><a accesskey=1 href="#String%20Streams">String Streams</a>:               Streams that get data from or put data in
+<li><a accesskey=1 href="#String Streams">String Streams</a>:               Streams that get data from or put data in
                                  a string or memory buffer. 
-<li><a accesskey=2 href="#Obstack%20Streams">Obstack Streams</a>: 		Streams that store data in an obstack. 
-<li><a accesskey=3 href="#Custom%20Streams">Custom Streams</a>:               Defining your own streams with an arbitrary
+<li><a accesskey=2 href="#Obstack Streams">Obstack Streams</a>: 		Streams that store data in an obstack. 
+<li><a accesskey=3 href="#Custom Streams">Custom Streams</a>:               Defining your own streams with an arbitrary
                                  input data source and/or output data sink. 
 </ul>
 
 <p><hr>
-Node:<a name="String%20Streams">String Streams</a>,
-Next:<a rel=next accesskey=n href="#Obstack%20Streams">Obstack Streams</a>,
-Up:<a rel=up accesskey=u href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>
+Node:<a name="String Streams">String Streams</a>,
+Next:<a rel=next accesskey=n href="#Obstack Streams">Obstack Streams</a>,
+Up:<a rel=up accesskey=u href="#Other Kinds of Streams">Other Kinds of Streams</a>
 <br>
 
 <h4>String Streams</h4>
 
@@ -27769,31 +27180,30 @@
 I/O to a string or memory buffer.  These facilities are declared in
 <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>fmemopen</b><i> (void *<var>buf</var>, size_t <var>size</var>, const char *<var>opentype</var>)
-</i></td>
+<td align="left"><code>FILE * <b>fmemopen</b><i> (void *<var>buf</var>, size_t <var>size</var>, const char *<var>opentype</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens a stream that allows the access specified by the
 <var>opentype</var> argument, that reads from or writes to the buffer specified
 by the argument <var>buf</var>.  This array must be at least <var>size</var> bytes long.
 
 <p>If you specify a null pointer as the <var>buf</var> argument, <code>fmemopen</code>
 dynamically allocates an array <var>size</var> bytes long (as with <code>malloc</code>;
-see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>).  This is really only useful
+see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>).  This is really only useful
 if you are going to write things to the buffer and then read them back
 in again, because you have no way of actually getting a pointer to the
 buffer (for this, try <code>open_memstream</code>, below).  The buffer is
 freed when the stream is closed.
 
 <p>The argument <var>opentype</var> is the same as in <code>fopen</code>
-(see <a href="#Opening%20Streams">Opening Streams</a>).  If the <var>opentype</var> specifies
+(see <a href="#Opening Streams">Opening Streams</a>).  If the <var>opentype</var> specifies
 append mode, then the initial file position is set to the first null
 character in the buffer.  Otherwise the initial file position is at the
 beginning of the buffer.
 
@@ -27845,19 +27255,18 @@
 Got r
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>open_memstream</b><i> (char **<var>ptr</var>, size_t *<var>sizeloc</var>)
-</i></td>
+<td align="left"><code>FILE * <b>open_memstream</b><i> (char **<var>ptr</var>, size_t *<var>sizeloc</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens a stream for writing to a buffer.  The buffer is
-allocated dynamically (as with <code>malloc</code>; see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>) and grown as necessary.
+allocated dynamically (as with <code>malloc</code>; see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>) and grown as necessary.
 
 <p>When the stream is closed with <code>fclose</code> or flushed with
 <code>fflush</code>, the locations <var>ptr</var> and <var>sizeloc</var> are updated to
 contain the pointer to the buffer and its size.  The values thus stored
@@ -27868,9 +27277,9 @@
 <p>A null character is written at the end of the buffer.  This null character
 is <em>not</em> included in the size value stored at <var>sizeloc</var>.
 
 <p>You can move the stream's file position with <code>fseek</code> or
-<code>fseeko</code> (see <a href="#File%20Positioning">File Positioning</a>).  Moving the file position past
+<code>fseeko</code> (see <a href="#File Positioning">File Positioning</a>).  Moving the file position past
 the end of the data already written fills the intervening space with
 zeroes. 
 </td></tr>
 </table>
@@ -27890,55 +27299,54 @@
 
   stream = open_memstream (&amp;bp, &amp;size);
   fprintf (stream, "hello");
   fflush (stream);
-  printf ("buf = `%s', size = %d\n", bp, size);
+  printf ("buf = '%s', size = %d\n", bp, size);
   fprintf (stream, ", world");
   fclose (stream);
-  printf ("buf = `%s', size = %d\n", bp, size);
+  printf ("buf = '%s', size = %d\n", bp, size);
 
   return 0;
 }
 </pre>
 
 <p>This program produces the following output:
 
-<br><pre>buf = `hello', size = 5
-buf = `hello, world', size = 12
+<br><pre>buf = 'hello', size = 5
+buf = 'hello, world', size = 12
 </pre>
 
 <p><hr>
-Node:<a name="Obstack%20Streams">Obstack Streams</a>,
-Next:<a rel=next accesskey=n href="#Custom%20Streams">Custom Streams</a>,
-Previous:<a rel=previous accesskey=p href="#String%20Streams">String Streams</a>,
-Up:<a rel=up accesskey=u href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>
+Node:<a name="Obstack Streams">Obstack Streams</a>,
+Next:<a rel=next accesskey=n href="#Custom Streams">Custom Streams</a>,
+Previous:<a rel=previous accesskey=p href="#String Streams">String Streams</a>,
+Up:<a rel=up accesskey=u href="#Other Kinds of Streams">Other Kinds of Streams</a>
 <br>
 
 <h4>Obstack Streams</h4>
 
 <p>You can open an output stream that puts it data in an obstack. 
 See <a href="#Obstacks">Obstacks</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>open_obstack_stream</b><i> (struct obstack *<var>obstack</var>)
-</i></td>
+<td align="left"><code>FILE * <b>open_obstack_stream</b><i> (struct obstack *<var>obstack</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens a stream for writing data into the obstack <var>obstack</var>. 
 This starts an object in the obstack and makes it grow as data is
-written (see <a href="#Growing%20Objects">Growing Objects</a>).
+written (see <a href="#Growing Objects">Growing Objects</a>).
 
 <p>Calling <code>fflush</code> on this stream updates the current size of the
 object to match the amount of data that has been written.  After a call
 to <code>fflush</code>, you can examine the object temporarily.
 
 <p>You can move the file position of an obstack stream with <code>fseek</code> or
-<code>fseeko</code> (see <a href="#File%20Positioning">File Positioning</a>).  Moving the file position past
+<code>fseeko</code> (see <a href="#File Positioning">File Positioning</a>).  Moving the file position past
 the end of the data written fills the intervening space with zeros.
 
 <p>To make the object permanent, update the obstack with <code>fflush</code>, and
 then use <code>obstack_finish</code> to finalize the object and get its address. 
@@ -27946,9 +27354,9 @@
 and later writes add to that object until you do another <code>fflush</code>
 and <code>obstack_finish</code>.
 
 <p>But how do you find out how long the object is?  You can get the length
-in bytes by calling <code>obstack_object_size</code> (see <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>), or you can null-terminate the object like this:
+in bytes by calling <code>obstack_object_size</code> (see <a href="#Status of an Obstack">Status of an Obstack</a>), or you can null-terminate the object like this:
 
 <br><pre>obstack_1grow (<var>obstack</var>, 0);
 </pre>
 
@@ -27973,11 +27381,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Custom%20Streams">Custom Streams</a>,
-Previous:<a rel=previous accesskey=p href="#Obstack%20Streams">Obstack Streams</a>,
-Up:<a rel=up accesskey=u href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>
+Node:<a name="Custom Streams">Custom Streams</a>,
+Previous:<a rel=previous accesskey=p href="#Obstack Streams">Obstack Streams</a>,
+Up:<a rel=up accesskey=u href="#Other Kinds of Streams">Other Kinds of Streams</a>
 <br>
 
 <h4>Programming Your Own Custom Streams</h4>
 
@@ -27986,18 +27394,18 @@
 programmed by you.  We call these <dfn>custom streams</dfn>.  The functions
 and types described here are all GNU extensions.
 
 <ul>
-<li><a accesskey=1 href="#Streams%20and%20Cookies">Streams and Cookies</a>:          The <dfn>cookie</dfn> records where to fetch or
+<li><a accesskey=1 href="#Streams and Cookies">Streams and Cookies</a>:          The <dfn>cookie</dfn> records where to fetch or
                                  store data that is read or written. 
-<li><a accesskey=2 href="#Hook%20Functions">Hook Functions</a>:               How you should define the four <dfn>hook
+<li><a accesskey=2 href="#Hook Functions">Hook Functions</a>:               How you should define the four <dfn>hook
                                  functions</dfn> that a custom stream needs. 
 </ul>
 
 <p><hr>
-Node:<a name="Streams%20and%20Cookies">Streams and Cookies</a>,
-Next:<a rel=next accesskey=n href="#Hook%20Functions">Hook Functions</a>,
-Up:<a rel=up accesskey=u href="#Custom%20Streams">Custom Streams</a>
+Node:<a name="Streams and Cookies">Streams and Cookies</a>,
+Next:<a rel=next accesskey=n href="#Hook Functions">Hook Functions</a>,
+Up:<a rel=up accesskey=u href="#Custom Streams">Custom Streams</a>
 <br>
 
 <h5>Custom Streams and Cookies</h5>
 
@@ -28022,16 +27430,15 @@
 
 <p>These facilities are declared in <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>cookie_io_functions_t</b><i>
-</i></td>
+<td align="left"><code><b>cookie_io_functions_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a structure type that holds the functions that define the
 communications protocol between the stream and its cookie.  It has
 the following members:
@@ -28063,32 +27470,31 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>fopencookie</b><i> (void *<var>cookie</var>, const char *<var>opentype</var>, cookie_io_functions_t <var>io-functions</var>)
-</i></td>
+<td align="left"><code>FILE * <b>fopencookie</b><i> (void *<var>cookie</var>, const char *<var>opentype</var>, cookie_io_functions_t <var>io-functions</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function actually creates the stream for communicating with the
 <var>cookie</var> using the functions in the <var>io-functions</var> argument. 
 The <var>opentype</var> argument is interpreted as for <code>fopen</code>;
-see <a href="#Opening%20Streams">Opening Streams</a>.  (But note that the "truncate on
+see <a href="#Opening Streams">Opening Streams</a>.  (But note that the "truncate on
 open" option is ignored.)  The new stream is fully buffered.
 
 <p>The <code>fopencookie</code> function returns the newly created stream, or a null
 pointer in case of an error. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Hook%20Functions">Hook Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Streams%20and%20Cookies">Streams and Cookies</a>,
-Up:<a rel=up accesskey=u href="#Custom%20Streams">Custom Streams</a>
+Node:<a name="Hook Functions">Hook Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Streams and Cookies">Streams and Cookies</a>,
+Up:<a rel=up accesskey=u href="#Custom Streams">Custom Streams</a>
 <br>
 
 <h5>Custom Stream Hook Functions</h5>
 
@@ -28099,9 +27505,9 @@
 
 <br><pre>ssize_t <var>reader</var> (void *<var>cookie</var>, char *<var>buffer</var>, size_t <var>size</var>)
 </pre>
 
-<p>This is very similar to the <code>read</code> function; see <a href="#I%2fO%20Primitives">I/O Primitives</a>.  Your function should transfer up to <var>size</var> bytes into
+<p>This is very similar to the <code>read</code> function; see <a href="#I%2fO Primitives">I/O Primitives</a>.  Your function should transfer up to <var>size</var> bytes into
 the <var>buffer</var>, and return the number of bytes read, or zero to
 indicate end-of-file.  You can return a value of <code>-1</code> to indicate
 an error.
 
@@ -28109,9 +27515,9 @@
 
 <br><pre>ssize_t <var>writer</var> (void *<var>cookie</var>, const char *<var>buffer</var>, size_t <var>size</var>)
 </pre>
 
-<p>This is very similar to the <code>write</code> function; see <a href="#I%2fO%20Primitives">I/O Primitives</a>.  Your function should transfer up to <var>size</var> bytes from
+<p>This is very similar to the <code>write</code> function; see <a href="#I%2fO Primitives">I/O Primitives</a>.  Your function should transfer up to <var>size</var> bytes from
 the buffer, and return the number of bytes written.  You can return a
 value of <code>-1</code> to indicate an error.
 
 <p>You should define the function to perform seek operations on the cookie
@@ -28120,9 +27526,9 @@
 <br><pre>int <var>seeker</var> (void *<var>cookie</var>, fpos_t *<var>position</var>, int <var>whence</var>)
 </pre>
 
 <p>For this function, the <var>position</var> and <var>whence</var> arguments are
-interpreted as for <code>fgetpos</code>; see <a href="#Portable%20Positioning">Portable Positioning</a>.  In
+interpreted as for <code>fgetpos</code>; see <a href="#Portable Positioning">Portable Positioning</a>.  In
 the GNU library, <code>fpos_t</code> is equivalent to <code>off_t</code> or
 <code>long int</code>, and simply represents the number of bytes from the
 beginning of the file.
 
@@ -28140,68 +27546,64 @@
 <p>Your function should return <code>-1</code> to indicate an error, and <code>0</code>
 otherwise.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>cookie_read_function</b><i>
-</i></td>
+<td align="left"><code><b>cookie_read_function</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type that the read function for a custom stream should have. 
 If you declare the function as shown above, this is the type it will have. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>cookie_write_function</b><i>
-</i></td>
+<td align="left"><code><b>cookie_write_function</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The data type of the write function for a custom stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>cookie_seek_function</b><i>
-</i></td>
+<td align="left"><code><b>cookie_seek_function</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The data type of the seek function for a custom stream. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>cookie_close_function</b><i>
-</i></td>
+<td align="left"><code><b>cookie_close_function</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The data type of the close function for a custom stream. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Formatted%20Messages">Formatted Messages</a>,
-Previous:<a rel=previous accesskey=p href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>,
-Up:<a rel=up accesskey=u href="#I%2fO%20on%20Streams">I/O on Streams</a>
+Node:<a name="Formatted Messages">Formatted Messages</a>,
+Previous:<a rel=previous accesskey=p href="#Other Kinds of Streams">Other Kinds of Streams</a>,
+Up:<a rel=up accesskey=u href="#I%2fO on Streams">I/O on Streams</a>
 <br>
 
 <h3>Formatted Messages</h3>
 
@@ -28211,17 +27613,17 @@
 and the strictness tests of the <code>fmtmsg</code> function ensure that the
 programmer follows some minimal requirements.
 
 <ul>
-<li><a accesskey=1 href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>:    The <code>fmtmsg</code> function. 
-<li><a accesskey=2 href="#Adding%20Severity%20Classes">Adding Severity Classes</a>:        Add more severity classes. 
+<li><a accesskey=1 href="#Printing Formatted Messages">Printing Formatted Messages</a>:    The <code>fmtmsg</code> function. 
+<li><a accesskey=2 href="#Adding Severity Classes">Adding Severity Classes</a>:        Add more severity classes. 
 <li><a accesskey=3 href="#Example">Example</a>:                        How to use <code>fmtmsg</code> and <code>addseverity</code>. 
 </ul>
 
 <p><hr>
-Node:<a name="Printing%20Formatted%20Messages">Printing Formatted Messages</a>,
-Next:<a rel=next accesskey=n href="#Adding%20Severity%20Classes">Adding Severity Classes</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Messages">Formatted Messages</a>
+Node:<a name="Printing Formatted Messages">Printing Formatted Messages</a>,
+Next:<a rel=next accesskey=n href="#Adding Severity Classes">Adding Severity Classes</a>,
+Up:<a rel=up accesskey=u href="#Formatted Messages">Formatted Messages</a>
 <br>
 
 <h4>Printing Formatted Messages</h4>
 
@@ -28273,16 +27675,15 @@
 <dd>It is a non-recoverable error. 
 </dl>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fmtmsg</b><i> (long int <var>classification</var>, const char *<var>label</var>, int <var>severity</var>, const char *<var>text</var>, const char *<var>action</var>, const char *<var>tag</var>)
-</i></td>
+<td align="left"><code>int <b>fmtmsg</b><i> (long int <var>classification</var>, const char *<var>label</var>, int <var>severity</var>, const char *<var>text</var>, const char *<var>action</var>, const char *<var>tag</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Display a message described by its parameters on the device(s) specified
 in the <var>classification</var> parameter.  The <var>label</var> parameter
 identifies the source of the message.  The string should consist of two
@@ -28336,9 +27737,9 @@
 <p>The numeric value of these five macros are between <code>0</code> and
 <code>4</code>.  Using the environment variable <code>SEV_LEVEL</code> or using the
 <code>addseverity</code> function one can add more severity levels with their
 corresponding string to print.  This is described below
-(see <a href="#Adding%20Severity%20Classes">Adding Severity Classes</a>).
+(see <a href="#Adding Severity Classes">Adding Severity Classes</a>).
 
 <p>If no parameter is ignored the output looks like this:
 
 <br><pre><var>label</var>: <var>severity-string</var>: <var>text</var>
@@ -28405,12 +27806,12 @@
 this class is processed by <code>fmtmsg</code> (see above, <code>fmtsmg</code> does
 not print the numeric value but instead the string representation).
 
 <p><hr>
-Node:<a name="Adding%20Severity%20Classes">Adding Severity Classes</a>,
+Node:<a name="Adding Severity Classes">Adding Severity Classes</a>,
 Next:<a rel=next accesskey=n href="#Example">Example</a>,
-Previous:<a rel=previous accesskey=p href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Messages">Formatted Messages</a>
+Previous:<a rel=previous accesskey=p href="#Printing Formatted Messages">Printing Formatted Messages</a>,
+Up:<a rel=up accesskey=u href="#Formatted Messages">Formatted Messages</a>
 <br>
 
 <h4>Adding Severity Classes</h4>
 
@@ -28420,16 +27821,15 @@
 <code>setenv</code> or <code>putenv</code> function to set the environment variable,
 but this is toilsome.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>addseverity</b><i> (int <var>severity</var>, const char *<var>string</var>)
-</i></td>
+<td align="left"><code>int <b>addseverity</b><i> (int <var>severity</var>, const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function allows the introduction of new severity classes which can be
 addressed by the <var>severity</var> parameter of the <code>fmtmsg</code> function. 
 The <var>severity</var> parameter of <code>addseverity</code> must match the value
@@ -28455,10 +27855,10 @@
 </table>
 
 <p><hr>
 Node:<a name="Example">Example</a>,
-Previous:<a rel=previous accesskey=p href="#Adding%20Severity%20Classes">Adding Severity Classes</a>,
-Up:<a rel=up accesskey=u href="#Formatted%20Messages">Formatted Messages</a>
+Previous:<a rel=previous accesskey=p href="#Adding Severity Classes">Adding Severity Classes</a>,
+Up:<a rel=up accesskey=u href="#Formatted Messages">Formatted Messages</a>
 <br>
 
 <h4>How to use <code>fmtmsg</code> and <code>addseverity</code></h4>
 
@@ -28505,9 +27905,9 @@
 colons and the <code>TO FIX</code> string) are printed.  But only one of the
 three calls to <code>fmtmsg</code> produced output.  The first call does not
 print anything because the <var>label</var> parameter is not in the correct
 form.  The string must contain two fields, separated by a colon
-(see <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>).  The third <code>fmtmsg</code> call
+(see <a href="#Printing Formatted Messages">Printing Formatted Messages</a>).  The third <code>fmtmsg</code> call
 produced no output since the class with the numeric value <code>6</code> is
 not defined.  Although a class with numeric value <code>5</code> is also not
 defined by default, the call to <code>addseverity</code> introduces it and
 the second call to <code>fmtmsg</code> produces the above output.
@@ -28542,19 +27942,19 @@
 not necessary since there is no more output on this line because the text
 is missing.
 
 <p><hr>
-Node:<a name="Low-Level%20I%2fO">Low-Level I/O</a>,
-Next:<a rel=next accesskey=n href="#File%20System%20Interface">File System Interface</a>,
-Previous:<a rel=previous accesskey=p href="#I%2fO%20on%20Streams">I/O on Streams</a>,
+Node:<a name="Low-Level I%2fO">Low-Level I/O</a>,
+Next:<a rel=next accesskey=n href="#File System Interface">File System Interface</a>,
+Previous:<a rel=previous accesskey=p href="#I%2fO on Streams">I/O on Streams</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Low-Level Input/Output</h2>
 
 <p>This chapter describes functions for performing low-level input/output
 operations on file descriptors.  These functions include the primitives
-for the higher-level I/O functions described in <a href="#I%2fO%20on%20Streams">I/O on Streams</a>, as
+for the higher-level I/O functions described in <a href="#I%2fO on Streams">I/O on Streams</a>, as
 well as functions for performing low-level control operations for which
 there are no equivalents on streams.
 
 <p>Stream-level I/O is more flexible and usually more convenient;
@@ -28575,43 +27975,43 @@
 directly.) 
 </ul>
 
 <ul>
-<li><a accesskey=1 href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>:            How to open and close file
+<li><a accesskey=1 href="#Opening and Closing Files">Opening and Closing Files</a>:            How to open and close file
                                          descriptors. 
-<li><a accesskey=2 href="#I%2fO%20Primitives">I/O Primitives</a>:                       Reading and writing data. 
-<li><a accesskey=3 href="#File%20Position%20Primitive">File Position Primitive</a>:              Setting a descriptor's file
+<li><a accesskey=2 href="#I%2fO Primitives">I/O Primitives</a>:                       Reading and writing data. 
+<li><a accesskey=3 href="#File Position Primitive">File Position Primitive</a>:              Setting a descriptor's file
                                          position. 
-<li><a accesskey=4 href="#Descriptors%20and%20Streams">Descriptors and Streams</a>:              Converting descriptor to stream
+<li><a accesskey=4 href="#Descriptors and Streams">Descriptors and Streams</a>:              Converting descriptor to stream
                                          or vice-versa. 
-<li><a accesskey=5 href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>:        Precautions needed if you use both
+<li><a accesskey=5 href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>:        Precautions needed if you use both
                                          descriptors and streams. 
 <li><a accesskey=6 href="#Scatter-Gather">Scatter-Gather</a>:                       Fast I/O to discontinuous buffers. 
-<li><a accesskey=7 href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>:                    Using files like memory. 
-<li><a accesskey=8 href="#Waiting%20for%20I%2fO">Waiting for I/O</a>:                      How to check for input or output
+<li><a accesskey=7 href="#Memory-mapped I%2fO">Memory-mapped I/O</a>:                    Using files like memory. 
+<li><a accesskey=8 href="#Waiting for I%2fO">Waiting for I/O</a>:                      How to check for input or output
 					 on multiple file descriptors. 
-<li><a accesskey=9 href="#Synchronizing%20I%2fO">Synchronizing I/O</a>:                    Making sure all I/O actions completed. 
-<li><a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>:                     Perform I/O in parallel. 
-<li><a href="#Control%20Operations">Control Operations</a>:                   Various other operations on file
+<li><a accesskey=9 href="#Synchronizing I%2fO">Synchronizing I/O</a>:                    Making sure all I/O actions completed. 
+<li><a href="#Asynchronous I%2fO">Asynchronous I/O</a>:                     Perform I/O in parallel. 
+<li><a href="#Control Operations">Control Operations</a>:                   Various other operations on file
 					 descriptors. 
-<li><a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>:              Fcntl commands for duplicating
+<li><a href="#Duplicating Descriptors">Duplicating Descriptors</a>:              Fcntl commands for duplicating
                                          file descriptors. 
-<li><a href="#Descriptor%20Flags">Descriptor Flags</a>:                     Fcntl commands for manipulating
+<li><a href="#Descriptor Flags">Descriptor Flags</a>:                     Fcntl commands for manipulating
                                          flags associated with file
                                          descriptors. 
-<li><a href="#File%20Status%20Flags">File Status Flags</a>:                    Fcntl commands for manipulating
+<li><a href="#File Status Flags">File Status Flags</a>:                    Fcntl commands for manipulating
                                          flags associated with open files. 
-<li><a href="#File%20Locks">File Locks</a>:                           Fcntl commands for implementing
+<li><a href="#File Locks">File Locks</a>:                           Fcntl commands for implementing
                                          file locking. 
-<li><a href="#Interrupt%20Input">Interrupt Input</a>:                      Getting an asynchronous signal when
+<li><a href="#Interrupt Input">Interrupt Input</a>:                      Getting an asynchronous signal when
                                          input arrives. 
 <li><a href="#IOCTLs">IOCTLs</a>:                               Generic I/O Control operations. 
 </ul>
 
 <p><hr>
-Node:<a name="Opening%20and%20Closing%20Files">Opening and Closing Files</a>,
-Next:<a rel=next accesskey=n href="#I%2fO%20Primitives">I/O Primitives</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Opening and Closing Files">Opening and Closing Files</a>,
+Next:<a rel=next accesskey=n href="#I%2fO Primitives">I/O Primitives</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Opening and Closing Files</h3>
 
@@ -28620,16 +28020,15 @@
 declared in the header file <code>fcntl.h</code>, while <code>close</code> is
 declared in <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>open</b><i> (const char *<var>filename</var>, int <var>flags</var>[, mode_t <var>mode</var>])
-</i></td>
+<td align="left"><code>int <b>open</b><i> (const char *<var>filename</var>, int <var>flags</var>[, mode_t <var>mode</var>])</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>open</code> function creates and returns a new file descriptor
 for the file named by <var>filename</var>.  Initially, the file position
 indicator for the file is at the beginning of the file.  The argument
@@ -28638,13 +28037,13 @@
 
 <p>The <var>flags</var> argument controls how the file is to be opened.  This is
 a bit mask; you create the value by the bitwise OR of the appropriate
 parameters (using the <code>|</code> operator in C). 
-See <a href="#File%20Status%20Flags">File Status Flags</a>, for the parameters available.
+See <a href="#File Status Flags">File Status Flags</a>, for the parameters available.
 
 <p>The normal return value from <code>open</code> is a non-negative integer file
 descriptor.  In the case of an error, a value of -1 is returned
-instead.  In addition to the usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following <code>errno</code> error conditions are defined
+instead.  In addition to the usual file name errors (see <a href="#File Name Errors">File Name Errors</a>), the following <code>errno</code> error conditions are defined
 for this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -28657,17 +28056,17 @@
 exists.
 
 <br><dt><code>EINTR</code>
 <dd>The <code>open</code> operation was interrupted by a signal. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>EISDIR</code>
 <dd>The <var>flags</var> argument specified write access, and the file is a directory.
 
 <br><dt><code>EMFILE</code>
 <dd>The process has too many files open. 
 The maximum number of file descriptors is controlled by the
-<code>RLIMIT_NOFILE</code> resource limit; see <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>RLIMIT_NOFILE</code> resource limit; see <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>ENFILE</code>
 <dd>The entire system, or perhaps the file system which contains the
 directory, cannot support any additional open files at the moment. 
@@ -28681,9 +28080,9 @@
 extended, because there is no disk space left.
 
 <br><dt><code>ENXIO</code>
 <dd><code>O_NONBLOCK</code> and <code>O_WRONLY</code> are both set in the <var>flags</var>
-argument, the file named by <var>filename</var> is a FIFO (see <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>), and no process has the file open for reading.
+argument, the file named by <var>filename</var> is a FIFO (see <a href="#Pipes and FIFOs">Pipes and FIFOs</a>), and no process has the file open for reading.
 
 <br><dt><code>EROFS</code>
 <dd>The file resides on a read-only file system and any of <code>O_WRONLY</code>,
 <code>O_RDWR</code>, and <code>O_TRUNC</code> are set in the <var>flags</var> argument,
@@ -28709,16 +28108,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>open64</b><i> (const char *<var>filename</var>, int <var>flags</var>[, mode_t <var>mode</var>])
-</i></td>
+<td align="left"><code>int <b>open64</b><i> (const char *<var>filename</var>, int <var>flags</var>[, mode_t <var>mode</var>])</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>open</code>.  It returns a file descriptor
 which can be used to access the file named by <var>filename</var>.  The only
 difference is that on 32 bit systems the file is opened in the
@@ -28731,16 +28129,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>creat</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>creat</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)</i></code></td>
 <td align="right">Obsolete function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is obsolete.  The call:
 
 <br><pre>creat (<var>filename</var>, <var>mode</var>)
@@ -28760,16 +28157,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>creat64</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>creat64</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)</i></code></td>
 <td align="right">Obsolete function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>creat</code>.  It returns a file descriptor
 which can be used to access the file named by <var>filename</var>.  The only
 the difference is that on 32 bit systems the file is opened in the
@@ -28785,16 +28181,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>close</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>int <b>close</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>close</code> closes the file descriptor <var>filedes</var>. 
 Closing a file has the following consequences:
 
@@ -28823,9 +28218,9 @@
 <dd>The <var>filedes</var> argument is not a valid file descriptor.
 
 <br><dt><code>EINTR</code>
 <dd>The <code>close</code> call was interrupted by a signal. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>. 
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>. 
 Here is an example of how to handle <code>EINTR</code> properly:
 
 <br><pre>TEMP_FAILURE_RETRY (close (desc));
 </pre>
@@ -28833,9 +28228,9 @@
 <br><dt><code>ENOSPC</code>
 <dt><code>EIO</code>
 <dt><code>EDQUOT</code>
 <dd>When the file is accessed by NFS, these errors from <code>write</code> can sometimes
-not be detected until <code>close</code>.  See <a href="#I%2fO%20Primitives">I/O Primitives</a>, for details
+not be detected until <code>close</code>.  See <a href="#I%2fO Primitives">I/O Primitives</a>, for details
 on their meaning. 
 </dl>
 
 <p>Please note that there is <em>no</em> separate <code>close64</code> function. 
@@ -28845,18 +28240,18 @@
 this situation. 
 </td></tr>
 </table>
 
-<p>To close a stream, call <code>fclose</code> (see <a href="#Closing%20Streams">Closing Streams</a>) instead
+<p>To close a stream, call <code>fclose</code> (see <a href="#Closing Streams">Closing Streams</a>) instead
 of trying to close its underlying file descriptor with <code>close</code>. 
 This flushes any buffered output and updates the stream object to
 indicate that it is closed.
 
 <p><hr>
-Node:<a name="I%2fO%20Primitives">I/O Primitives</a>,
-Next:<a rel=next accesskey=n href="#File%20Position%20Primitive">File Position Primitive</a>,
-Previous:<a rel=previous accesskey=p href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="I%2fO Primitives">I/O Primitives</a>,
+Next:<a rel=next accesskey=n href="#File Position Primitive">File Position Primitive</a>,
+Previous:<a rel=previous accesskey=p href="#Opening and Closing Files">Opening and Closing Files</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Input and Output Primitives</h3>
 
@@ -28865,32 +28260,30 @@
 <code>lseek</code>.  These functions are declared in the header file
 <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>ssize_t</b><i>
-</i></td>
+<td align="left"><code><b>ssize_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used to represent the sizes of blocks that can be
 read or written in a single operation.  It is similar to <code>size_t</code>,
 but must be a signed type. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>read</b><i> (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>read</b><i> (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>read</code> function reads up to <var>size</var> bytes from the file
 with descriptor <var>filedes</var>, storing the results in the <var>buffer</var>. 
 (This is not necessarily a character string, and no terminating null
@@ -28917,9 +28310,9 @@
 <dl>
 <dt><code>EAGAIN</code>
 <dd>Normally, when no input is immediately available, <code>read</code> waits for
 some input.  But if the <code>O_NONBLOCK</code> flag is set for the file
-(see <a href="#File%20Status%20Flags">File Status Flags</a>), <code>read</code> returns immediately without
+(see <a href="#File Status Flags">File Status Flags</a>), <code>read</code> returns immediately without
 reading any data, and reports this error.
 
 <p><strong>Compatibility Note:</strong> Most versions of BSD Unix use a different
 error code for this: <code>EWOULDBLOCK</code>.  In the GNU library,
@@ -28943,9 +28336,9 @@
 or is not open for reading.
 
 <br><dt><code>EINTR</code>
 <dd><code>read</code> was interrupted by a signal while it was waiting for input. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.  A signal will not necessary cause
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>.  A signal will not necessary cause
 <code>read</code> to return <code>EINTR</code>; it may instead result in a
 successful <code>read</code> which returns fewer bytes than requested.
 
 <br><dt><code>EIO</code>
@@ -28955,10 +28348,10 @@
 <p><code>EIO</code> also occurs when a background process tries to read from the
 controlling terminal, and the normal action of stopping the process by
 sending it a <code>SIGTTIN</code> signal isn't working.  This might happen if
 the signal is being blocked or ignored, or because the process group is
-orphaned.  See <a href="#Job%20Control">Job Control</a>, for more information about job control,
-and <a href="#Signal%20Handling">Signal Handling</a>, for information about signals. 
+orphaned.  See <a href="#Job Control">Job Control</a>, for more information about job control,
+and <a href="#Signal Handling">Signal Handling</a>, for information about signals. 
 </dl>
 
 <p>Please note that there is no function named <code>read64</code>.  This is not
 necessary since this function does not directly modify or handle the
@@ -28977,16 +28370,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>pread</b><i> (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>, off_t <var>offset</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>pread</b><i> (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>, off_t <var>offset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pread</code> function is similar to the <code>read</code> function.  The
 first three arguments are identical, and the return values and error
 codes also correspond.
@@ -29020,16 +28412,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>pread64</b><i> (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>, off64_t <var>offset</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>pread64</b><i> (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>, off64_t <var>offset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>pread</code> function.  The difference
 is that the <var>offset</var> parameter is of type <code>off64_t</code> instead of
 <code>off_t</code> which makes it possible on 32 bit machines to address
@@ -29044,16 +28435,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>write</b><i> (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>write</b><i> (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>write</code> function writes up to <var>size</var> bytes from
 <var>buffer</var> to the file with descriptor <var>filedes</var>.  The data in
 <var>buffer</var> is not necessarily a character string and a null character is
@@ -29072,17 +28462,17 @@
 within a minute or less.)  Modern systems provide another function
 <code>fdatasync</code> which guarantees integrity only for the file data and
 is therefore faster. 
 You can use the <code>O_FSYNC</code> open mode to make <code>write</code> always
-store the data to disk before returning; see <a href="#Operating%20Modes">Operating Modes</a>.
+store the data to disk before returning; see <a href="#Operating Modes">Operating Modes</a>.
 
 <p>In the case of an error, <code>write</code> returns -1.  The following
 <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EAGAIN</code>
 <dd>Normally, <code>write</code> blocks until the write operation is complete. 
-But if the <code>O_NONBLOCK</code> flag is set for the file (see <a href="#Control%20Operations">Control Operations</a>), it returns immediately without writing any data and
+But if the <code>O_NONBLOCK</code> flag is set for the file (see <a href="#Control Operations">Control Operations</a>), it returns immediately without writing any data and
 reports this error.  An example of a situation that might cause the
 process to block on output is writing to a terminal device that supports
 flow control, where output has been suspended by receipt of a STOP
 character.
@@ -29111,9 +28501,9 @@
 <dd>The <code>write</code> operation was interrupted by a signal while it was
 blocked waiting for completion.  A signal will not necessarily cause
 <code>write</code> to return <code>EINTR</code>; it may instead result in a
 successful <code>write</code> which writes fewer bytes than requested. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>EIO</code>
 <dd>For many devices, and for disk files, this error code indicates
 a hardware error.
@@ -29123,15 +28513,15 @@
 
 <br><dt><code>EPIPE</code>
 <dd>This error is returned when you try to write to a pipe or FIFO that
 isn't open for reading by any process.  When this happens, a <code>SIGPIPE</code>
-signal is also sent to the process; see <a href="#Signal%20Handling">Signal Handling</a>. 
+signal is also sent to the process; see <a href="#Signal Handling">Signal Handling</a>. 
 </dl>
 
 <p>Unless you have arranged to prevent <code>EINTR</code> failures, you should
 check <code>errno</code> after each failing call to <code>write</code>, and if the
 error was <code>EINTR</code>, you should simply repeat the call. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.  The easy way to do this is with the
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>.  The easy way to do this is with the
 macro <code>TEMP_FAILURE_RETRY</code>, as follows:
 
 <br><pre>nbytes = TEMP_FAILURE_RETRY (write (desc, buffer, count));
 </pre>
@@ -29153,16 +28543,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>pwrite</b><i> (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>, off_t <var>offset</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>pwrite</b><i> (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>, off_t <var>offset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pwrite</code> function is similar to the <code>write</code> function.  The
 first three arguments are identical, and the return values and error codes
 also correspond.
@@ -29196,16 +28585,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>pwrite64</b><i> (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>, off64_t <var>offset</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>pwrite64</b><i> (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>, off64_t <var>offset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>pwrite</code> function.  The difference
 is that the <var>offset</var> parameter is of type <code>off64_t</code> instead of
 <code>off_t</code> which makes it possible on 32 bit machines to address
@@ -29220,34 +28608,33 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="File%20Position%20Primitive">File Position Primitive</a>,
-Next:<a rel=next accesskey=n href="#Descriptors%20and%20Streams">Descriptors and Streams</a>,
-Previous:<a rel=previous accesskey=p href="#I%2fO%20Primitives">I/O Primitives</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="File Position Primitive">File Position Primitive</a>,
+Next:<a rel=next accesskey=n href="#Descriptors and Streams">Descriptors and Streams</a>,
+Previous:<a rel=previous accesskey=p href="#I%2fO Primitives">I/O Primitives</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Setting the File Position of a Descriptor</h3>
 
 <p>Just as you can set the file position of a stream with <code>fseek</code>, you
 can set the file position of a descriptor with <code>lseek</code>.  This
 specifies the position in the file for the next <code>read</code> or
-<code>write</code> operation.  See <a href="#File%20Positioning">File Positioning</a>, for more information
+<code>write</code> operation.  See <a href="#File Positioning">File Positioning</a>, for more information
 on the file position and what it means.
 
 <p>To read the current file position value from a descriptor, use
 <code>lseek (<var>desc</var>, 0, SEEK_CUR)</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">off_t <b>lseek</b><i> (int <var>filedes</var>, off_t <var>offset</var>, int <var>whence</var>)
-</i></td>
+<td align="left"><code>off_t <b>lseek</b><i> (int <var>filedes</var>, off_t <var>offset</var>, int <var>whence</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lseek</code> function is used to change the file position of the
 file with descriptor <var>filedes</var>.
 
@@ -29282,9 +28669,9 @@
 <p>If you want to append to the file, setting the file position to the
 current end of file with <code>SEEK_END</code> is not sufficient.  Another
 process may write more data after you seek but before you write,
 extending the file so the position you write onto clobbers their data. 
-Instead, use the <code>O_APPEND</code> operating mode; see <a href="#Operating%20Modes">Operating Modes</a>.
+Instead, use the <code>O_APPEND</code> operating mode; see <a href="#Operating Modes">Operating Modes</a>.
 
 <p>You can set the file position past the current end of the file.  This
 does not by itself make the file longer; <code>lseek</code> never changes the
 file.  But subsequent output at that position will extend the file. 
@@ -29332,16 +28719,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">off64_t <b>lseek64</b><i> (int <var>filedes</var>, off64_t <var>offset</var>, int <var>whence</var>)
-</i></td>
+<td align="left"><code>off64_t <b>lseek64</b><i> (int <var>filedes</var>, off64_t <var>offset</var>, int <var>whence</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>lseek</code> function.  The difference
 is that the <var>offset</var> parameter is of type <code>off64_t</code> instead of
 <code>off_t</code> which makes it possible on 32 bit machines to address
@@ -29397,16 +28783,15 @@
 <code>foo</code>, and then four more characters starting with the 1028'th
 character.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>off_t</b><i>
-</i></td>
+<td align="left"><code><b>off_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an arithmetic data type used to represent file sizes. 
 In the GNU system, this is equivalent to <code>fpos_t</code> or <code>long int</code>.
 
@@ -29415,16 +28800,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>off64_t</b><i>
-</i></td>
+<td align="left"><code><b>off64_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This type is used similar to <code>off_t</code>.  The difference is that even
 on 32 bit machines, where the <code>off_t</code> type would have 32 bits,
 <code>off64_t</code> has 64 bits and so is able to address files up to
@@ -29450,12 +28834,12 @@
 <dd>An alias for <code>SEEK_END</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Descriptors%20and%20Streams">Descriptors and Streams</a>,
-Next:<a rel=next accesskey=n href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Position%20Primitive">File Position Primitive</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Descriptors and Streams">Descriptors and Streams</a>,
+Next:<a rel=next accesskey=n href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>,
+Previous:<a rel=previous accesskey=p href="#File Position Primitive">File Position Primitive</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Descriptors and Streams</h3>
 
@@ -29464,22 +28848,21 @@
 an existing stream with the <code>fileno</code> function.  These functions are
 declared in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>fdopen</b><i> (int <var>filedes</var>, const char *<var>opentype</var>)
-</i></td>
+<td align="left"><code>FILE * <b>fdopen</b><i> (int <var>filedes</var>, const char *<var>opentype</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fdopen</code> function returns a new stream for the file descriptor
 <var>filedes</var>.
 
 <p>The <var>opentype</var> argument is interpreted in the same way as for the
-<code>fopen</code> function (see <a href="#Opening%20Streams">Opening Streams</a>), except that
+<code>fopen</code> function (see <a href="#Opening Streams">Opening Streams</a>), except that
 the <code>b</code> option is not permitted; this is because GNU makes no
 distinction between text and binary files.  Also, <code>"w"</code> and
 <code>"w+"</code> do not cause truncation of the file; these have an effect only
 when opening a file, and in this case the file has already been opened. 
@@ -29497,19 +28880,18 @@
 </td></tr>
 </table>
 
 <p>For an example showing the use of the <code>fdopen</code> function,
-see <a href="#Creating%20a%20Pipe">Creating a Pipe</a>.
+see <a href="#Creating a Pipe">Creating a Pipe</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fileno</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fileno</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the file descriptor associated with the stream
 <var>stream</var>.  If an error is detected (for example, if the <var>stream</var>
 is not valid) or if <var>stream</var> does not do I/O to a file,
@@ -29517,16 +28899,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fileno_unlocked</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fileno_unlocked</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fileno_unlocked</code> function is equivalent to the <code>fileno</code>
 function except that it does not implicitly lock the stream if the state
 is <code>FSETLOCKING_INTERNAL</code>.
@@ -29536,9 +28917,9 @@
 </table>
 
 <p>There are also symbolic constants defined in <code>unistd.h</code> for the
 file descriptors belonging to the standard streams <code>stdin</code>,
-<code>stdout</code>, and <code>stderr</code>; see <a href="#Standard%20Streams">Standard Streams</a>.
+<code>stdout</code>, and <code>stderr</code>; see <a href="#Standard Streams">Standard Streams</a>.
 
 <dl>
 <dt><code>STDIN_FILENO</code>
 <dd>This macro has value <code>0</code>, which is the file descriptor for
@@ -29553,12 +28934,12 @@
 standard error output. 
 </dl>
 
 <p><hr>
-Node:<a name="Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>,
+Node:<a name="Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>,
 Next:<a rel=next accesskey=n href="#Scatter-Gather">Scatter-Gather</a>,
-Previous:<a rel=previous accesskey=p href="#Descriptors%20and%20Streams">Descriptors and Streams</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Previous:<a rel=previous accesskey=p href="#Descriptors and Streams">Descriptors and Streams</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Dangers of Mixing Streams and Descriptors</h3>
 
@@ -29576,18 +28957,18 @@
 stream from the descriptor with <code>fdopen</code> and then do all I/O with
 the stream.
 
 <ul>
-<li><a accesskey=1 href="#Linked%20Channels">Linked Channels</a>: 	   Dealing with channels sharing a file position. 
-<li><a accesskey=2 href="#Independent%20Channels">Independent Channels</a>:    Dealing with separately opened, unlinked channels. 
-<li><a accesskey=3 href="#Cleaning%20Streams">Cleaning Streams</a>: 	   Cleaning a stream makes it safe to use
+<li><a accesskey=1 href="#Linked Channels">Linked Channels</a>: 	   Dealing with channels sharing a file position. 
+<li><a accesskey=2 href="#Independent Channels">Independent Channels</a>:    Dealing with separately opened, unlinked channels. 
+<li><a accesskey=3 href="#Cleaning Streams">Cleaning Streams</a>: 	   Cleaning a stream makes it safe to use
                             another channel. 
 </ul>
 
 <p><hr>
-Node:<a name="Linked%20Channels">Linked Channels</a>,
-Next:<a rel=next accesskey=n href="#Independent%20Channels">Independent Channels</a>,
-Up:<a rel=up accesskey=u href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>
+Node:<a name="Linked Channels">Linked Channels</a>,
+Next:<a rel=next accesskey=n href="#Independent Channels">Independent Channels</a>,
+Up:<a rel=up accesskey=u href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>
 <br>
 
 <h4>Linked Channels</h4>
 
@@ -29603,21 +28984,21 @@
 
 <p>If you have been using a stream for I/O, and you want to do I/O using
 another channel (either a stream or a descriptor) that is linked to it,
 you must first <dfn>clean up</dfn> the stream that you have been using. 
-See <a href="#Cleaning%20Streams">Cleaning Streams</a>.
+See <a href="#Cleaning Streams">Cleaning Streams</a>.
 
 <p>Terminating a process, or executing a new program in the process,
 destroys all the streams in the process.  If descriptors linked to these
 streams persist in other processes, their file positions become
 undefined as a result.  To prevent this, you must clean up the streams
 before destroying them.
 
 <p><hr>
-Node:<a name="Independent%20Channels">Independent Channels</a>,
-Next:<a rel=next accesskey=n href="#Cleaning%20Streams">Cleaning Streams</a>,
-Previous:<a rel=previous accesskey=p href="#Linked%20Channels">Linked Channels</a>,
-Up:<a rel=up accesskey=u href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>
+Node:<a name="Independent Channels">Independent Channels</a>,
+Next:<a rel=next accesskey=n href="#Cleaning Streams">Cleaning Streams</a>,
+Previous:<a rel=previous accesskey=p href="#Linked Channels">Linked Channels</a>,
+Up:<a rel=up accesskey=u href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>
 <br>
 
 <h4>Independent Channels</h4>
 
@@ -29652,29 +29033,28 @@
 <p>It's impossible for two channels to have separate file pointers for a
 file that doesn't support random access.  Thus, channels for reading or
 writing such files are always linked, never independent.  Append-type
 channels are also always linked.  For these channels, follow the rules
-for linked channels; see <a href="#Linked%20Channels">Linked Channels</a>.
+for linked channels; see <a href="#Linked Channels">Linked Channels</a>.
 
 <p><hr>
-Node:<a name="Cleaning%20Streams">Cleaning Streams</a>,
-Previous:<a rel=previous accesskey=p href="#Independent%20Channels">Independent Channels</a>,
-Up:<a rel=up accesskey=u href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>
+Node:<a name="Cleaning Streams">Cleaning Streams</a>,
+Previous:<a rel=previous accesskey=p href="#Independent Channels">Independent Channels</a>,
+Up:<a rel=up accesskey=u href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>
 <br>
 
 <h4>Cleaning Streams</h4>
 
 <p>On the GNU system, you can clean up any stream with <code>fclean</code>:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fclean</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>fclean</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Clean up the stream <var>stream</var> so that its buffer is empty.  If
 <var>stream</var> is doing output, force it out.  If <var>stream</var> is doing
 input, give the data in the buffer back to the system, arranging to
@@ -29712,15 +29092,15 @@
 simultaneously.  However, text already "output" to a stream but still
 buffered by the stream will be subject to the new terminal modes when
 subsequently flushed.  To make sure "past" output is covered by the
 terminal settings that were in effect at the time, flush the output
-streams for that terminal before setting the modes.  See <a href="#Terminal%20Modes">Terminal Modes</a>.
+streams for that terminal before setting the modes.  See <a href="#Terminal Modes">Terminal Modes</a>.
 
 <p><hr>
 Node:<a name="Scatter-Gather">Scatter-Gather</a>,
-Next:<a rel=next accesskey=n href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>,
-Previous:<a rel=previous accesskey=p href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Next:<a rel=next accesskey=n href="#Memory-mapped I%2fO">Memory-mapped I/O</a>,
+Previous:<a rel=previous accesskey=p href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Fast Scatter-Gather I/O</h3>
 
@@ -29738,16 +29118,15 @@
 <p>These functions are controlled with arrays of <code>iovec</code> structures,
 which describe the location and size of each buffer.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct iovec</b><i>
-</i></td>
+<td align="left"><code><b>struct iovec</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>iovec</code> structure describes a buffer. It contains two fields:
 
@@ -29763,16 +29142,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>readv</b><i> (int <var>filedes</var>, const struct iovec *<var>vector</var>, int <var>count</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>readv</b><i> (int <var>filedes</var>, const struct iovec *<var>vector</var>, int <var>count</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>readv</code> function reads data from <var>filedes</var> and scatters it
 into the buffers described in <var>vector</var>, which is taken to be
@@ -29789,16 +29167,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>writev</b><i> (int <var>filedes</var>, const struct iovec *<var>vector</var>, int <var>count</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>writev</b><i> (int <var>filedes</var>, const struct iovec *<var>vector</var>, int <var>count</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>writev</code> function gathers data from the buffers described in
 <var>vector</var>, which is taken to be <var>count</var> structures long, and writes
@@ -29820,12 +29197,12 @@
 (as opposed to the total output), are large.  In that case, a high-level
 stream would not be able to cache the data effectively.
 
 <p><hr>
-Node:<a name="Memory-mapped%20I%2fO">Memory-mapped I/O</a>,
-Next:<a rel=next accesskey=n href="#Waiting%20for%20I%2fO">Waiting for I/O</a>,
+Node:<a name="Memory-mapped I%2fO">Memory-mapped I/O</a>,
+Next:<a rel=next accesskey=n href="#Waiting for I%2fO">Waiting for I/O</a>,
 Previous:<a rel=previous accesskey=p href="#Scatter-Gather">Scatter-Gather</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Memory-mapped I/O</h3>
 
@@ -29857,16 +29234,15 @@
 
 <p>These functions are declared in <code>sys/mman.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>mmap</b><i> (void *<var>address</var>, size_t <var>length</var>,int <var>protect</var>, int <var>flags</var>, int <var>filedes</var>, off_t <var>offset</var>)
-</i></td>
+<td align="left"><code>void * <b>mmap</b><i> (void *<var>address</var>, size_t <var>length</var>,int <var>protect</var>, int <var>flags</var>, int <var>filedes</var>, off_t <var>offset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>mmap</code> function creates a new mapping, connected to bytes
 (<var>offset</var>) to (<var>offset</var> + <var>length</var> - 1) in the file open on
@@ -29880,9 +29256,9 @@
 
 <p><var>protect</var> contains flags that control what kind of access is
 permitted.  They include <code>PROT_READ</code>, <code>PROT_WRITE</code>, and
 <code>PROT_EXEC</code>, which permit reading, writing, and execution,
-respectively.  Inappropriate access will cause a segfault (see <a href="#Program%20Error%20Signals">Program Error Signals</a>).
+respectively.  Inappropriate access will cause a segfault (see <a href="#Program Error Signals">Program Error Signals</a>).
 
 <p>Note that most hardware designs cannot support write permission without
 read permission, and many do not distinguish read and execute permission. 
 Thus, you may receive wider permissions than you ask for, and mappings of
@@ -29967,16 +29343,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>mmap64</b><i> (void *<var>address</var>, size_t <var>length</var>,int <var>protect</var>, int <var>flags</var>, int <var>filedes</var>, off64_t <var>offset</var>)
-</i></td>
+<td align="left"><code>void * <b>mmap64</b><i> (void *<var>address</var>, size_t <var>length</var>,int <var>protect</var>, int <var>flags</var>, int <var>filedes</var>, off64_t <var>offset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mmap64</code> function is equivalent to the <code>mmap</code> function but
 the <var>offset</var> parameter is of type <code>off64_t</code>.  On 32-bit systems
 this allows the file associated with the <var>filedes</var> descriptor to be
@@ -29991,16 +29366,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>munmap</b><i> (void *<var>addr</var>, size_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>munmap</b><i> (void *<var>addr</var>, size_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>munmap</code> removes any memory maps from (<var>addr</var>) to (<var>addr</var> +
 <var>length</var>).  <var>length</var> should be the length of the mapping.
@@ -30025,16 +29399,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>msync</b><i> (void *<var>address</var>, size_t <var>length</var>, int <var>flags</var>)
-</i></td>
+<td align="left"><code>int <b>msync</b><i> (void *<var>address</var>, size_t <var>length</var>, int <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>When using shared mappings, the kernel can write the file at any time
 before the mapping is removed.  To be certain data has actually been
@@ -30078,16 +29451,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>mremap</b><i> (void *<var>address</var>, size_t <var>length</var>, size_t <var>new_length</var>, int <var>flag</var>)
-</i></td>
+<td align="left"><code>void * <b>mremap</b><i> (void *<var>address</var>, size_t <var>length</var>, size_t <var>new_length</var>, int <var>flag</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function can be used to change the size of an existing memory
 area. <var>address</var> and <var>length</var> must cover a region entirely mapped
@@ -30111,9 +29483,9 @@
 <dd>The address given is misaligned or inappropriate.
 
 <br><dt><code>EAGAIN</code>
 <dd>The region has pages locked, and if extended it would exceed the
-process's resource limit for locked pages.  See <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+process's resource limit for locked pages.  See <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>ENOMEM</code>
 <dd>The region is private writable, and insufficient virtual memory is
 available to extend it.  Also, this error will occur if
@@ -30133,16 +29505,15 @@
 not support mapping at all.  Thus, programs using <code>mmap</code> should
 have a fallback method to use should it fail. See <a href="standards.html#Mmap">Mmap</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>madvise</b><i> (void *<var>addr</var>, size_t <var>length</var>, int <var>advice</var>)
-</i></td>
+<td align="left"><code>int <b>madvise</b><i> (void *<var>addr</var>, size_t <var>length</var>, int <var>advice</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function can be used to provide the system with <var>advice</var> about
 the intended usage patterns of the memory region starting at <var>addr</var>
@@ -30210,12 +29581,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Waiting%20for%20I%2fO">Waiting for I/O</a>,
-Next:<a rel=next accesskey=n href="#Synchronizing%20I%2fO">Synchronizing I/O</a>,
-Previous:<a rel=previous accesskey=p href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Waiting for I%2fO">Waiting for I/O</a>,
+Next:<a rel=next accesskey=n href="#Synchronizing I%2fO">Synchronizing I/O</a>,
+Previous:<a rel=previous accesskey=p href="#Memory-mapped I%2fO">Memory-mapped I/O</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Waiting for Input or Output</h3>
 
@@ -30239,40 +29610,38 @@
 facility is declared in the header file <code>sys/types.h</code>.
 
 <p>In the case of a server socket (see <a href="#Listening">Listening</a>), we say that
 "input" is available when there are pending connections that could be
-accepted (see <a href="#Accepting%20Connections">Accepting Connections</a>).  <code>accept</code> for server
+accepted (see <a href="#Accepting Connections">Accepting Connections</a>).  <code>accept</code> for server
 sockets blocks and interacts with <code>select</code> just as <code>read</code> does
 for normal input.
 
 <p>The file descriptor sets for the <code>select</code> function are specified
 as <code>fd_set</code> objects.  Here is the description of the data type
 and some macros for manipulating these objects.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>fd_set</b><i>
-</i></td>
+<td align="left"><code><b>fd_set</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fd_set</code> data type represents file descriptor sets for the
 <code>select</code> function.  It is actually a bit array. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>FD_SETSIZE</b><i>
-</i></td>
+<td align="left"><code>int <b>FD_SETSIZE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is the maximum number of file descriptors that a
 <code>fd_set</code> object can hold information about.  On systems with a
 fixed maximum number, <code>FD_SETSIZE</code> is at least that number.  On
@@ -30284,59 +29653,55 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>FD_ZERO</b><i> (fd_set *<var>set</var>)
-</i></td>
+<td align="left"><code>void <b>FD_ZERO</b><i> (fd_set *<var>set</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro initializes the file descriptor set <var>set</var> to be the
 empty set. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>FD_SET</b><i> (int <var>filedes</var>, fd_set *<var>set</var>)
-</i></td>
+<td align="left"><code>void <b>FD_SET</b><i> (int <var>filedes</var>, fd_set *<var>set</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro adds <var>filedes</var> to the file descriptor set <var>set</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>FD_CLR</b><i> (int <var>filedes</var>, fd_set *<var>set</var>)
-</i></td>
+<td align="left"><code>void <b>FD_CLR</b><i> (int <var>filedes</var>, fd_set *<var>set</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro removes <var>filedes</var> from the file descriptor set <var>set</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>FD_ISSET</b><i> (int <var>filedes</var>, fd_set *<var>set</var>)
-</i></td>
+<td align="left"><code>int <b>FD_ISSET</b><i> (int <var>filedes</var>, fd_set *<var>set</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value (true) if <var>filedes</var> is a member
 of the file descriptor set <var>set</var>, and zero (false) otherwise. 
 </td></tr>
@@ -30344,16 +29709,15 @@
 
 <p>Next, here is the description of the <code>select</code> function itself.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>select</b><i> (int <var>nfds</var>, fd_set *<var>read-fds</var>, fd_set *<var>write-fds</var>, fd_set *<var>except-fds</var>, struct timeval *<var>timeout</var>)
-</i></td>
+<td align="left"><code>int <b>select</b><i> (int <var>nfds</var>, fd_set *<var>read-fds</var>, fd_set *<var>write-fds</var>, fd_set *<var>except-fds</var>, struct timeval *<var>timeout</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>select</code> function blocks the calling process until there is
 activity on any of the specified sets of file descriptors, or until the
 timeout period has expired.
@@ -30367,9 +29731,9 @@
 
 <p>A file descriptor is considered ready for reading if it is not at end of
 file.  A server socket is considered ready for reading if there is a
 pending connection which can be accepted with <code>accept</code>;
-see <a href="#Accepting%20Connections">Accepting Connections</a>.  A client socket is ready for writing when
+see <a href="#Accepting Connections">Accepting Connections</a>.  A client socket is ready for writing when
 its connection is fully established; see <a href="#Connecting">Connecting</a>.
 
 <p>"Exceptional conditions" does not mean errors--errors are reported
 immediately when an erroneous system call is executed, and do not
@@ -30383,9 +29747,9 @@
 
 <p>The <var>timeout</var> specifies the maximum time to wait.  If you pass a
 null pointer for this argument, it means to block indefinitely until one
 of the file descriptors is ready.  Otherwise, you should provide the
-time in <code>struct timeval</code> format; see <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.  Specify zero as the time (a <code>struct timeval</code> containing
+time in <code>struct timeval</code> format; see <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.  Specify zero as the time (a <code>struct timeval</code> containing
 all zeros) if you want to find out which descriptors are ready without
 waiting if none are ready.
 
 <p>The normal return value from <code>select</code> is the total number of ready file
@@ -30401,9 +29765,9 @@
 program uses signals, you can't rely on <code>select</code> to keep waiting
 for the full time specified.  If you want to be sure of waiting for a
 particular amount of time, you must check for <code>EINTR</code> and repeat
 the <code>select</code> with a newly calculated timeout based on the current
-time.  See the example below.  See also <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+time.  See the example below.  See also <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <p>If an error occurs, <code>select</code> returns <code>-1</code> and does not modify
 the argument file descriptor sets.  The following <code>errno</code> error
 conditions are defined for this function:
@@ -30412,9 +29776,9 @@
 <dt><code>EBADF</code>
 <dd>One of the file descriptor sets specified an invalid file descriptor.
 
 <br><dt><code>EINTR</code>
-<dd>The operation was interrupted by a signal.  See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+<dd>The operation was interrupted by a signal.  See <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>EINVAL</code>
 <dd>The <var>timeout</var> argument is invalid; one of the components is negative
 or too large. 
@@ -30466,15 +29830,15 @@
 }
 </pre>
 
 <p>There is another example showing the use of <code>select</code> to multiplex
-input from multiple sockets in <a href="#Server%20Example">Server Example</a>.
+input from multiple sockets in <a href="#Server Example">Server Example</a>.
 
 <p><hr>
-Node:<a name="Synchronizing%20I%2fO">Synchronizing I/O</a>,
-Next:<a rel=next accesskey=n href="#Asynchronous%20I%2fO">Asynchronous I/O</a>,
-Previous:<a rel=previous accesskey=p href="#Waiting%20for%20I%2fO">Waiting for I/O</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Synchronizing I%2fO">Synchronizing I/O</a>,
+Next:<a rel=next accesskey=n href="#Asynchronous I%2fO">Asynchronous I/O</a>,
+Previous:<a rel=previous accesskey=p href="#Waiting for I%2fO">Waiting for I/O</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Synchronizing I/O operations</h3>
 
@@ -30487,16 +29851,15 @@
 special functions which ensure that all operations finish before
 they return.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sync</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>sync</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A call to this function will not return as long as there is data which
 has not been written to the device.  All dirty buffers in the kernel will
 be written and so an overall consistent system can be achieved (if no
@@ -30511,16 +29874,15 @@
 <p>Programs more often want to ensure that data written to a given file is
 committed, rather than all data in the system.  For this, <code>sync</code> is overkill.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fsync</b><i> (int <var>fildes</var>)
-</i></td>
+<td align="left"><code>int <b>fsync</b><i> (int <var>fildes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fsync</code> function can be used to make sure all data associated with
 the open file <var>fildes</var> is written to the device associated with the
 descriptor.  The function call does not return unless all actions have
@@ -30555,16 +29917,15 @@
 and leaving such information uncommitted does not prevent a successful
 recovering of the file in case of a problem.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fdatasync</b><i> (int <var>fildes</var>)
-</i></td>
+<td align="left"><code>int <b>fdatasync</b><i> (int <var>fildes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 When a call to the <code>fdatasync</code> function returns, it is ensured
 that all of the file data is written to the device.  For all pending I/O
 operations, the parts guaranteeing data integrity finished.
@@ -30589,12 +29950,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Asynchronous%20I%2fO">Asynchronous I/O</a>,
-Next:<a rel=next accesskey=n href="#Control%20Operations">Control Operations</a>,
-Previous:<a rel=previous accesskey=p href="#Synchronizing%20I%2fO">Synchronizing I/O</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Asynchronous I%2fO">Asynchronous I/O</a>,
+Next:<a rel=next accesskey=n href="#Control Operations">Control Operations</a>,
+Previous:<a rel=previous accesskey=p href="#Synchronizing I%2fO">Synchronizing I/O</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Perform I/O Operations in Parallel</h3>
 
@@ -30618,16 +29979,15 @@
 <code>struct aiocb</code> (<dfn>AIO control block</dfn>).  It is defined in
 <code>aio.h</code> as follows.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct aiocb</b><i>
-</i></td>
+<td align="left"><code><b>struct aiocb</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The POSIX.1b standard mandates that the <code>struct aiocb</code> structure
 contains at least the members described in the following table.  There
 might be more elements which are used by the implementation, but
@@ -30709,16 +30069,15 @@
 types but otherwise is equivalent to <code>struct aiocb</code>.  Particularly,
 all member names are the same.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct aiocb64</b><i>
-</i></td>
+<td align="left"><code><b>struct aiocb64</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <dl>
 <dt><code>int aio_fildes</code>
 <dd>This element specifies the file descriptor which is used for the
@@ -30774,32 +30133,31 @@
 </td></tr>
 </table>
 
 <ul>
-<li><a accesskey=1 href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>:     Asynchronous Read and Write Operations. 
-<li><a accesskey=2 href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>:      Getting the Status of AIO Operations. 
-<li><a accesskey=3 href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>:  Getting into a consistent state. 
-<li><a accesskey=4 href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>:         Cancellation of AIO Operations. 
-<li><a accesskey=5 href="#Configuration%20of%20AIO">Configuration of AIO</a>:          How to optimize the AIO implementation. 
+<li><a accesskey=1 href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>:     Asynchronous Read and Write Operations. 
+<li><a accesskey=2 href="#Status of AIO Operations">Status of AIO Operations</a>:      Getting the Status of AIO Operations. 
+<li><a accesskey=3 href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>:  Getting into a consistent state. 
+<li><a accesskey=4 href="#Cancel AIO Operations">Cancel AIO Operations</a>:         Cancellation of AIO Operations. 
+<li><a accesskey=5 href="#Configuration of AIO">Configuration of AIO</a>:          How to optimize the AIO implementation. 
 </ul>
 
 <p><hr>
-Node:<a name="Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>,
-Next:<a rel=next accesskey=n href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>,
-Up:<a rel=up accesskey=u href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
+Node:<a name="Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>,
+Next:<a rel=next accesskey=n href="#Status of AIO Operations">Status of AIO Operations</a>,
+Up:<a rel=up accesskey=u href="#Asynchronous I%2fO">Asynchronous I/O</a>
 <br>
 
 <h4>Asynchronous Read and Write Operations</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_read</b><i> (struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_read</b><i> (struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function initiates an asynchronous read operation.  It
 immediately returns after the operation was enqueued or when an
 error was encountered.
@@ -30851,9 +30209,9 @@
 <dt><code>EBADF</code>
 <dd>The <code>aiocbp-&gt;aio_fildes</code> descriptor is not valid. 
 <br><dt><code>ECANCELED</code>
 <dd>The operation was canceled before the operation was finished
-(see <a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>)
+(see <a href="#Cancel AIO Operations">Cancel AIO Operations</a>)
 <br><dt><code>EINVAL</code>
 <dd>The <code>aiocbp-&gt;aio_offset</code> value is invalid. 
 </dl>
 
@@ -30863,21 +30221,20 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_read64</b><i> (struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_read64</b><i> (struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>aio_read</code> function.  The only
 difference is that on 32&nbsp;bit machines, the file descriptor should
 be opened in the large file mode.  Internally, <code>aio_read64</code> uses
-functionality equivalent to <code>lseek64</code> (see <a href="#File%20Position%20Primitive">File Position Primitive</a>) to position the file descriptor correctly for the reading,
+functionality equivalent to <code>lseek64</code> (see <a href="#File Position Primitive">File Position Primitive</a>) to position the file descriptor correctly for the reading,
 as opposed to <code>lseek</code> functionality used in <code>aio_read</code>.
 
 <p>When the sources are compiled with <code>_FILE_OFFSET_BITS == 64</code>, this
 function is available under the name <code>aio_read</code> and so transparently
@@ -30888,16 +30245,15 @@
 <p>To write data asynchronously to a file, there exists an equivalent pair
 of functions with a very similar interface.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_write</b><i> (struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_write</b><i> (struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function initiates an asynchronous write operation.  The function
 call immediately returns after the operation was enqueued or if before
 this happens an error was encountered.
@@ -30950,9 +30306,9 @@
 <dt><code>EBADF</code>
 <dd>The <code>aiocbp-&gt;aio_fildes</code> descriptor is not valid. 
 <br><dt><code>ECANCELED</code>
 <dd>The operation was canceled before the operation was finished. 
-(see <a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>)
+(see <a href="#Cancel AIO Operations">Cancel AIO Operations</a>)
 <br><dt><code>EINVAL</code>
 <dd>The <code>aiocbp-&gt;aio_offset</code> value is invalid. 
 </dl>
 
@@ -30962,21 +30318,20 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_write64</b><i> (struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_write64</b><i> (struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>aio_write</code> function.  The only
 difference is that on 32&nbsp;bit machines the file descriptor should
 be opened in the large file mode.  Internally <code>aio_write64</code> uses
-functionality equivalent to <code>lseek64</code> (see <a href="#File%20Position%20Primitive">File Position Primitive</a>) to position the file descriptor correctly for the writing,
+functionality equivalent to <code>lseek64</code> (see <a href="#File Position Primitive">File Position Primitive</a>) to position the file descriptor correctly for the writing,
 as opposed to <code>lseek</code> functionality used in <code>aio_write</code>.
 
 <p>When the sources are compiled with <code>_FILE_OFFSET_BITS == 64</code>, this
 function is available under the name <code>aio_write</code> and so transparently
@@ -30990,16 +30345,15 @@
 operations.  It is therefore similar to a combination of <code>readv</code> and
 <code>writev</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>lio_listio</b><i> (int <var>mode</var>, struct aiocb *const <var>list</var>[], int <var>nent</var>, struct sigevent *<var>sig</var>)
-</i></td>
+<td align="left"><code>int <b>lio_listio</b><i> (int <var>mode</var>, struct aiocb *const <var>list</var>[], int <var>nent</var>, struct sigevent *<var>sig</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lio_listio</code> function can be used to enqueue an arbitrary
 number of read and write requests at one time.  The requests can all be
 meant for the same file, all for different files or every solution in
@@ -31016,9 +30370,9 @@
 in which case this element of <var>list</var> is simply ignored.  This
 "operation" is useful in situations where one has a fixed array of
 <code>struct aiocb</code> elements from which only a few need to be handled at
 a time.  Another situation is where the <code>lio_listio</code> call was
-canceled before all requests are processed (see <a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>) and the remaining requests have to be reissued.
+canceled before all requests are processed (see <a href="#Cancel AIO Operations">Cancel AIO Operations</a>) and the remaining requests have to be reissued.
 
 <p>The other members of each element of the array pointed to by
 <code>list</code> must have values suitable for the operation as described in
 the documentation for <code>aio_read</code> and <code>aio_write</code> above.
@@ -31080,21 +30434,20 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>lio_listio64</b><i> (int <var>mode</var>, struct aiocb *const <var>list</var>, int <var>nent</var>, struct sigevent *<var>sig</var>)
-</i></td>
+<td align="left"><code>int <b>lio_listio64</b><i> (int <var>mode</var>, struct aiocb *const <var>list</var>, int <var>nent</var>, struct sigevent *<var>sig</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>lio_listio</code> function.  The only
 difference is that on 32&nbsp;bit machines, the file descriptor should
 be opened in the large file mode.  Internally, <code>lio_listio64</code> uses
-functionality equivalent to <code>lseek64</code> (see <a href="#File%20Position%20Primitive">File Position Primitive</a>) to position the file descriptor correctly for the reading or
+functionality equivalent to <code>lseek64</code> (see <a href="#File Position Primitive">File Position Primitive</a>) to position the file descriptor correctly for the reading or
 writing, as opposed to <code>lseek</code> functionality used in
 <code>lio_listio</code>.
 
 <p>When the sources are compiled with <code>_FILE_OFFSET_BITS == 64</code>, this
@@ -31104,12 +30457,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Status%20of%20AIO%20Operations">Status of AIO Operations</a>,
-Next:<a rel=next accesskey=n href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>,
-Previous:<a rel=previous accesskey=p href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>,
-Up:<a rel=up accesskey=u href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
+Node:<a name="Status of AIO Operations">Status of AIO Operations</a>,
+Next:<a rel=next accesskey=n href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>,
+Previous:<a rel=previous accesskey=p href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>,
+Up:<a rel=up accesskey=u href="#Asynchronous I%2fO">Asynchronous I/O</a>
 <br>
 
 <h4>Getting the Status of AIO Operations</h4>
 
@@ -31121,16 +30474,15 @@
 specific request already terminated and if so, what the result was. 
 The following two functions allow you to get this kind of information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_error</b><i> (const struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_error</b><i> (const struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function determines the error state of the request described by the
 <code>struct aiocb</code> variable pointed to by <var>aiocbp</var>.  If the
 request has not yet terminated the value returned is always
@@ -31150,16 +30502,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_error64</b><i> (const struct aiocb64 *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_error64</b><i> (const struct aiocb64 *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>aio_error</code> with the only difference
 that the argument is a reference to a variable of type <code>struct
 aiocb64</code>.
@@ -31171,16 +30522,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ssize_t <b>aio_return</b><i> (const struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>ssize_t <b>aio_return</b><i> (const struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function can be used to retrieve the return status of the operation
 carried out by the request described in the variable pointed to by
 <var>aiocbp</var>.  As long as the error status of this request as returned
@@ -31202,16 +30552,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_return64</b><i> (const struct aiocb64 *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_return64</b><i> (const struct aiocb64 *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>aio_return</code> with the only difference
 that the argument is a reference to a variable of type <code>struct
 aiocb64</code>.
@@ -31223,12 +30572,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>,
-Next:<a rel=next accesskey=n href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>,
-Previous:<a rel=previous accesskey=p href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>,
-Up:<a rel=up accesskey=u href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
+Node:<a name="Synchronizing AIO Operations">Synchronizing AIO Operations</a>,
+Next:<a rel=next accesskey=n href="#Cancel AIO Operations">Cancel AIO Operations</a>,
+Previous:<a rel=previous accesskey=p href="#Status of AIO Operations">Status of AIO Operations</a>,
+Up:<a rel=up accesskey=u href="#Asynchronous I%2fO">Asynchronous I/O</a>
 <br>
 
 <h4>Getting into a Consistent State</h4>
 
@@ -31243,21 +30592,20 @@
 <p>The <code>aio_fsync</code> and <code>aio_fsync64</code> functions are only available
 if the symbol <code>_POSIX_SYNCHRONIZED_IO</code> is defined in <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_fsync</b><i> (int <var>op</var>, struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_fsync</b><i> (int <var>op</var>, struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Calling this function forces all I/O operations operating queued at the
 time of the function call operating on the file descriptor
 <code>aiocbp-&gt;aio_fildes</code> into the synchronized I/O completion state
-(see <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>).  The <code>aio_fsync</code> function returns
+(see <a href="#Synchronizing I%2fO">Synchronizing I/O</a>).  The <code>aio_fsync</code> function returns
 immediately but the notification through the method described in
 <code>aiocbp-&gt;aio_sigevent</code> will happen only after all requests for this
 file descriptor have terminated and the file is synchronized.  This also
 means that requests for this very same file descriptor which are queued
@@ -31299,16 +30647,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_fsync64</b><i> (int <var>op</var>, struct aiocb64 *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_fsync64</b><i> (int <var>op</var>, struct aiocb64 *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>aio_fsync</code> with the only difference
 that the argument is a reference to a variable of type <code>struct
 aiocb64</code>.
@@ -31333,16 +30680,15 @@
 before the current client is served.  For situations like this
 <code>aio_suspend</code> should be used.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_suspend</b><i> (const struct aiocb *const <var>list</var>[], int <var>nent</var>, const struct timespec *<var>timeout</var>)
-</i></td>
+<td align="left"><code>int <b>aio_suspend</b><i> (const struct aiocb *const <var>list</var>[], int <var>nent</var>, const struct timespec *<var>timeout</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 When calling this function, the calling thread is suspended until at
 least one of the requests pointed to by the <var>nent</var> elements of the
 array <var>list</var> has completed.  If any of the requests has already
@@ -31379,16 +30725,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_suspend64</b><i> (const struct aiocb64 *const <var>list</var>[], int <var>nent</var>, const struct timespec *<var>timeout</var>)
-</i></td>
+<td align="left"><code>int <b>aio_suspend64</b><i> (const struct aiocb64 *const <var>list</var>[], int <var>nent</var>, const struct timespec *<var>timeout</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>aio_suspend</code> with the only difference
 that the argument is a reference to a variable of type <code>struct
 aiocb64</code>.
@@ -31400,12 +30745,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Cancel%20AIO%20Operations">Cancel AIO Operations</a>,
-Next:<a rel=next accesskey=n href="#Configuration%20of%20AIO">Configuration of AIO</a>,
-Previous:<a rel=previous accesskey=p href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>,
-Up:<a rel=up accesskey=u href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
+Node:<a name="Cancel AIO Operations">Cancel AIO Operations</a>,
+Next:<a rel=next accesskey=n href="#Configuration of AIO">Configuration of AIO</a>,
+Previous:<a rel=previous accesskey=p href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>,
+Up:<a rel=up accesskey=u href="#Asynchronous I%2fO">Asynchronous I/O</a>
 <br>
 
 <h4>Cancellation of AIO Operations</h4>
 
@@ -31420,16 +30765,15 @@
 implementation to decide whether it is possible to cancel the operation
 or not.  Therefore using this function is merely a hint.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_cancel</b><i> (int <var>fildes</var>, struct aiocb *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_cancel</b><i> (int <var>fildes</var>, struct aiocb *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>aio_cancel</code> function can be used to cancel one or more
 outstanding requests.  If the <var>aiocbp</var> parameter is <code>NULL</code>, the
 function tries to cancel all of the outstanding requests which would process
@@ -31475,16 +30819,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>aio_cancel64</b><i> (int <var>fildes</var>, struct aiocb64 *<var>aiocbp</var>)
-</i></td>
+<td align="left"><code>int <b>aio_cancel64</b><i> (int <var>fildes</var>, struct aiocb64 *<var>aiocbp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>aio_cancel</code> with the only difference
 that the argument is a reference to a variable of type <code>struct
 aiocb64</code>.
@@ -31496,11 +30839,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Configuration%20of%20AIO">Configuration of AIO</a>,
-Previous:<a rel=previous accesskey=p href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>,
-Up:<a rel=up accesskey=u href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
+Node:<a name="Configuration of AIO">Configuration of AIO</a>,
+Previous:<a rel=previous accesskey=p href="#Cancel AIO Operations">Cancel AIO Operations</a>,
+Up:<a rel=up accesskey=u href="#Asynchronous I%2fO">Asynchronous I/O</a>
 <br>
 
 <h4>How to optimize the AIO implementation</h4>
 
@@ -31515,16 +30858,15 @@
 in the GNU C library.  Therefore, the GNU C library provides a means
 for tuning the AIO implementation according to the individual use.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct aioinit</b><i>
-</i></td>
+<td align="left"><code><b>struct aioinit</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used to pass the configuration or tunable parameters
 to the implementation.  The program has to initialize the members of
 this struct and pass it to the implementation using the <code>aio_init</code>
@@ -31551,16 +30893,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>aio_init</b><i> (const struct aioinit *<var>init</var>)
-</i></td>
+<td align="left"><code>void <b>aio_init</b><i> (const struct aioinit *<var>init</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function must be called before any other AIO function.  Calling it
 is completely voluntary, as it is only meant to help the AIO
 implementation perform better.
@@ -31576,12 +30917,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Control%20Operations">Control Operations</a>,
-Next:<a rel=next accesskey=n href="#Duplicating%20Descriptors">Duplicating Descriptors</a>,
-Previous:<a rel=previous accesskey=p href="#Asynchronous%20I%2fO">Asynchronous I/O</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Control Operations">Control Operations</a>,
+Next:<a rel=next accesskey=n href="#Duplicating Descriptors">Duplicating Descriptors</a>,
+Previous:<a rel=previous accesskey=p href="#Asynchronous I%2fO">Asynchronous I/O</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Control Operations on Files</h3>
 
@@ -31593,19 +30934,18 @@
 <p>The second argument to the <code>fcntl</code> function is a command that
 specifies which operation to perform.  The function and macros that name
 various flags that are used with it are declared in the header file
 <code>fcntl.h</code>.  Many of these flags are also used by the <code>open</code>
-function; see <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>.
+function; see <a href="#Opening and Closing Files">Opening and Closing Files</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fcntl</b><i> (int <var>filedes</var>, int <var>command</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>fcntl</b><i> (int <var>filedes</var>, int <var>command</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fcntl</code> function performs the operation specified by
 <var>command</var> on the file descriptor <var>filedes</var>.  Some commands
 require additional arguments to be supplied.  These additional arguments
@@ -31616,38 +30956,38 @@
 
 <dl>
 <dt><code>F_DUPFD</code>
 <dd>Duplicate the file descriptor (return another file descriptor pointing
-to the same open file).  See <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>.
+to the same open file).  See <a href="#Duplicating Descriptors">Duplicating Descriptors</a>.
 
 <br><dt><code>F_GETFD</code>
-<dd>Get flags associated with the file descriptor.  See <a href="#Descriptor%20Flags">Descriptor Flags</a>.
+<dd>Get flags associated with the file descriptor.  See <a href="#Descriptor Flags">Descriptor Flags</a>.
 
 <br><dt><code>F_SETFD</code>
-<dd>Set flags associated with the file descriptor.  See <a href="#Descriptor%20Flags">Descriptor Flags</a>.
+<dd>Set flags associated with the file descriptor.  See <a href="#Descriptor Flags">Descriptor Flags</a>.
 
 <br><dt><code>F_GETFL</code>
-<dd>Get flags associated with the open file.  See <a href="#File%20Status%20Flags">File Status Flags</a>.
+<dd>Get flags associated with the open file.  See <a href="#File Status Flags">File Status Flags</a>.
 
 <br><dt><code>F_SETFL</code>
-<dd>Set flags associated with the open file.  See <a href="#File%20Status%20Flags">File Status Flags</a>.
+<dd>Set flags associated with the open file.  See <a href="#File Status Flags">File Status Flags</a>.
 
 <br><dt><code>F_GETLK</code>
-<dd>Get a file lock.  See <a href="#File%20Locks">File Locks</a>.
+<dd>Get a file lock.  See <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>F_SETLK</code>
-<dd>Set or clear a file lock.  See <a href="#File%20Locks">File Locks</a>.
+<dd>Set or clear a file lock.  See <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>F_SETLKW</code>
-<dd>Like <code>F_SETLK</code>, but wait for completion.  See <a href="#File%20Locks">File Locks</a>.
+<dd>Like <code>F_SETLK</code>, but wait for completion.  See <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>F_GETOWN</code>
 <dd>Get process or process group ID to receive <code>SIGIO</code> signals. 
-See <a href="#Interrupt%20Input">Interrupt Input</a>.
+See <a href="#Interrupt Input">Interrupt Input</a>.
 
 <br><dt><code>F_SETOWN</code>
 <dd>Set process or process group ID to receive <code>SIGIO</code> signals. 
-See <a href="#Interrupt%20Input">Interrupt Input</a>. 
+See <a href="#Interrupt Input">Interrupt Input</a>. 
 </dl>
 
 <p>This function is a cancellation point in multi-threaded programs.  This
 is a problem if the thread allocates some resources (like memory, file
@@ -31658,21 +30998,21 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Duplicating%20Descriptors">Duplicating Descriptors</a>,
-Next:<a rel=next accesskey=n href="#Descriptor%20Flags">Descriptor Flags</a>,
-Previous:<a rel=previous accesskey=p href="#Control%20Operations">Control Operations</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Duplicating Descriptors">Duplicating Descriptors</a>,
+Next:<a rel=next accesskey=n href="#Descriptor Flags">Descriptor Flags</a>,
+Previous:<a rel=previous accesskey=p href="#Control Operations">Control Operations</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Duplicating Descriptors</h3>
 
 <p>You can <dfn>duplicate</dfn> a file descriptor, or allocate another file
 descriptor that refers to the same open file as the original.  Duplicate
 descriptors share one file position and one set of file status flags
-(see <a href="#File%20Status%20Flags">File Status Flags</a>), but each has its own set of file descriptor
-flags (see <a href="#Descriptor%20Flags">Descriptor Flags</a>).
+(see <a href="#File Status Flags">File Status Flags</a>), but each has its own set of file descriptor
+flags (see <a href="#Descriptor Flags">Descriptor Flags</a>).
 
 <p>The major use of duplicating a file descriptor is to implement
 <dfn>redirection</dfn> of input or output:  that is, to change the
 file or pipe that a particular file descriptor corresponds to.
@@ -31685,32 +31025,30 @@
 while prototypes for <code>dup</code> and <code>dup2</code> are in the header file
 <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>dup</b><i> (int <var>old</var>)
-</i></td>
+<td align="left"><code>int <b>dup</b><i> (int <var>old</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function copies descriptor <var>old</var> to the first available
 descriptor number (the first number not currently open).  It is
 equivalent to <code>fcntl (<var>old</var>, F_DUPFD, 0)</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>dup2</b><i> (int <var>old</var>, int <var>new</var>)
-</i></td>
+<td align="left"><code>int <b>dup2</b><i> (int <var>old</var>, int <var>new</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function copies the descriptor <var>old</var> to descriptor number
 <var>new</var>.
 
@@ -31732,16 +31070,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_DUPFD</b><i>
-</i></td>
+<td align="left"><code>int <b>F_DUPFD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 copy the file descriptor given as the first argument.
 
@@ -31768,9 +31105,9 @@
 
 <br><dt><code>EMFILE</code>
 <dd>There are no more file descriptors available--your program is already
 using the maximum.  In BSD and GNU, the maximum is controlled by a
-resource limit that can be changed; see <a href="#Limits%20on%20Resources">Limits on Resources</a>, for
+resource limit that can be changed; see <a href="#Limits on Resources">Limits on Resources</a>, for
 more information about the <code>RLIMIT_NOFILE</code> limit. 
 </dl>
 
 <p><code>ENFILE</code> is not a possible error code for <code>dup2</code> because
@@ -31783,9 +31120,9 @@
 
 <p>Here is an example showing how to use <code>dup2</code> to do redirection. 
 Typically, redirection of the standard streams (like <code>stdin</code>) is
 done by a shell or shell-like program before calling one of the
-<code>exec</code> functions (see <a href="#Executing%20a%20File">Executing a File</a>) to execute a new
+<code>exec</code> functions (see <a href="#Executing a File">Executing a File</a>) to execute a new
 program in a child process.  When the new program is executed, it
 creates and initializes the standard streams to point to the
 corresponding file descriptors, before its <code>main</code> function is
 invoked.
@@ -31807,15 +31144,15 @@
   }
 </pre>
 
 <p>There is also a more detailed example showing how to implement redirection
-in the context of a pipeline of processes in <a href="#Launching%20Jobs">Launching Jobs</a>.
+in the context of a pipeline of processes in <a href="#Launching Jobs">Launching Jobs</a>.
 
 <p><hr>
-Node:<a name="Descriptor%20Flags">Descriptor Flags</a>,
-Next:<a rel=next accesskey=n href="#File%20Status%20Flags">File Status Flags</a>,
-Previous:<a rel=previous accesskey=p href="#Duplicating%20Descriptors">Duplicating Descriptors</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="Descriptor Flags">Descriptor Flags</a>,
+Next:<a rel=next accesskey=n href="#File Status Flags">File Status Flags</a>,
+Previous:<a rel=previous accesskey=p href="#Duplicating Descriptors">Duplicating Descriptors</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>File Descriptor Flags</h3>
 
@@ -31825,22 +31162,21 @@
 from a single opening of a file, each descriptor has its own set of flags.
 
 <p>Currently there is just one file descriptor flag: <code>FD_CLOEXEC</code>,
 which causes the descriptor to be closed if you use any of the
-<code>exec<small>...</small></code> functions (see <a href="#Executing%20a%20File">Executing a File</a>).
+<code>exec<small>...</small></code> functions (see <a href="#Executing a File">Executing a File</a>).
 
 <p>The symbols in this section are defined in the header file
 <code>fcntl.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_GETFD</b><i>
-</i></td>
+<td align="left"><code>int <b>F_GETFD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 specify that it should return the file descriptor flags associated
 with the <var>filedes</var> argument.
@@ -31859,16 +31195,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_SETFD</b><i>
-</i></td>
+<td align="left"><code>int <b>F_SETFD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 specify that it should set the file descriptor flags associated with the
 <var>filedes</var> argument.  This requires a third <code>int</code> argument to
@@ -31888,19 +31223,18 @@
 the <code>fcntl</code> function.  The value is an integer constant usable
 as a bit mask value.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>FD_CLOEXEC</b><i>
-</i></td>
+<td align="left"><code>int <b>FD_CLOEXEC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This flag specifies that the file descriptor should be closed when
-an <code>exec</code> function is invoked; see <a href="#Executing%20a%20File">Executing a File</a>.  When
+an <code>exec</code> function is invoked; see <a href="#Executing a File">Executing a File</a>.  When
 a file descriptor is allocated (as with <code>open</code> or <code>dup</code>),
 this bit is initially cleared on the new file descriptor, meaning that
 descriptor will survive into the new program after <code>exec</code>. 
 </td></tr>
@@ -31934,52 +31268,52 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="File%20Status%20Flags">File Status Flags</a>,
-Next:<a rel=next accesskey=n href="#File%20Locks">File Locks</a>,
-Previous:<a rel=previous accesskey=p href="#Descriptor%20Flags">Descriptor Flags</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="File Status Flags">File Status Flags</a>,
+Next:<a rel=next accesskey=n href="#File Locks">File Locks</a>,
+Previous:<a rel=previous accesskey=p href="#Descriptor Flags">Descriptor Flags</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>File Status Flags</h3>
 
 <p><dfn>File status flags</dfn> are used to specify attributes of the opening of a
-file.  Unlike the file descriptor flags discussed in <a href="#Descriptor%20Flags">Descriptor Flags</a>, the file status flags are shared by duplicated file descriptors
+file.  Unlike the file descriptor flags discussed in <a href="#Descriptor Flags">Descriptor Flags</a>, the file status flags are shared by duplicated file descriptors
 resulting from a single opening of the file.  The file status flags are
 specified with the <var>flags</var> argument to <code>open</code>;
-see <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>.
+see <a href="#Opening and Closing Files">Opening and Closing Files</a>.
 
 <p>File status flags fall into three categories, which are described in the
 following sections.
 
 <ul>
-<li><a href="#Access%20Modes">Access Modes</a>, specify what type of access is allowed to the
+<li><a href="#Access Modes">Access Modes</a>, specify what type of access is allowed to the
 file: reading, writing, or both.  They are set by <code>open</code> and are
 returned by <code>fcntl</code>, but cannot be changed.
 
-<li><a href="#Open-time%20Flags">Open-time Flags</a>, control details of what <code>open</code> will do. 
+<li><a href="#Open-time Flags">Open-time Flags</a>, control details of what <code>open</code> will do. 
 These flags are not preserved after the <code>open</code> call.
 
-<li><a href="#Operating%20Modes">Operating Modes</a>, affect how operations such as <code>read</code> and
+<li><a href="#Operating Modes">Operating Modes</a>, affect how operations such as <code>read</code> and
 <code>write</code> are done.  They are set by <code>open</code>, and can be fetched or
 changed with <code>fcntl</code>. 
 </ul>
 
 <p>The symbols in this section are defined in the header file
 <code>fcntl.h</code>.
 
 <ul>
-<li><a accesskey=1 href="#Access%20Modes">Access Modes</a>:                 Whether the descriptor can read or write. 
-<li><a accesskey=2 href="#Open-time%20Flags">Open-time Flags</a>:              Details of <code>open</code>. 
-<li><a accesskey=3 href="#Operating%20Modes">Operating Modes</a>:              Special modes to control I/O operations. 
-<li><a accesskey=4 href="#Getting%20File%20Status%20Flags">Getting File Status Flags</a>:    Fetching and changing these flags. 
+<li><a accesskey=1 href="#Access Modes">Access Modes</a>:                 Whether the descriptor can read or write. 
+<li><a accesskey=2 href="#Open-time Flags">Open-time Flags</a>:              Details of <code>open</code>. 
+<li><a accesskey=3 href="#Operating Modes">Operating Modes</a>:              Special modes to control I/O operations. 
+<li><a accesskey=4 href="#Getting File Status Flags">Getting File Status Flags</a>:    Fetching and changing these flags. 
 </ul>
 
 <p><hr>
-Node:<a name="Access%20Modes">Access Modes</a>,
-Next:<a rel=next accesskey=n href="#Open-time%20Flags">Open-time Flags</a>,
-Up:<a rel=up accesskey=u href="#File%20Status%20Flags">File Status Flags</a>
+Node:<a name="Access Modes">Access Modes</a>,
+Next:<a rel=next accesskey=n href="#Open-time Flags">Open-time Flags</a>,
+Up:<a rel=up accesskey=u href="#File Status Flags">File Status Flags</a>
 <br>
 
 <h4>File Access Modes</h4>
 
@@ -31988,44 +31322,41 @@
 and allow execution of the file as a program.)  The access modes are chosen
 when the file is opened, and never change.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_RDONLY</b><i>
-</i></td>
+<td align="left"><code>int <b>O_RDONLY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Open the file for read access. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_WRONLY</b><i>
-</i></td>
+<td align="left"><code>int <b>O_WRONLY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Open the file for write access. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_RDWR</b><i>
-</i></td>
+<td align="left"><code>int <b>O_RDWR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Open the file for both reading and writing. 
 </td></tr>
 </table>
@@ -32042,44 +31373,41 @@
 But most programs will want to be portable to other POSIX.1 systems and
 should use the POSIX.1 names above instead.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_READ</b><i>
-</i></td>
+<td align="left"><code>int <b>O_READ</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Open the file for reading.  Same as <code>O_RDWR</code>; only defined on GNU. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_WRITE</b><i>
-</i></td>
+<td align="left"><code>int <b>O_WRITE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Open the file for reading.  Same as <code>O_WRONLY</code>; only defined on GNU. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_EXEC</b><i>
-</i></td>
+<td align="left"><code>int <b>O_EXEC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Open the file for executing.  Only defined on GNU. 
 </td></tr>
 </table>
@@ -32091,16 +31419,15 @@
 access modes are not stored as distinct bit flags.  The portable way to
 extract the file access mode bits is with <code>O_ACCMODE</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_ACCMODE</b><i>
-</i></td>
+<td align="left"><code>int <b>O_ACCMODE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro stands for a mask that can be bitwise-ANDed with the file
 status flag value to produce a value representing the file access mode. 
 The mode will be <code>O_RDONLY</code>, <code>O_WRONLY</code>, or <code>O_RDWR</code>. 
@@ -32109,20 +31436,20 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Open-time%20Flags">Open-time Flags</a>,
-Next:<a rel=next accesskey=n href="#Operating%20Modes">Operating Modes</a>,
-Previous:<a rel=previous accesskey=p href="#Access%20Modes">Access Modes</a>,
-Up:<a rel=up accesskey=u href="#File%20Status%20Flags">File Status Flags</a>
+Node:<a name="Open-time Flags">Open-time Flags</a>,
+Next:<a rel=next accesskey=n href="#Operating Modes">Operating Modes</a>,
+Previous:<a rel=previous accesskey=p href="#Access Modes">Access Modes</a>,
+Up:<a rel=up accesskey=u href="#File Status Flags">File Status Flags</a>
 <br>
 
 <h4>Open-time Flags</h4>
 
 <p>The open-time flags specify options affecting how <code>open</code> will behave. 
 These options are not preserved once the file is open.  The exception to
 this is <code>O_NONBLOCK</code>, which is also an I/O operating mode and so it
-<em>is</em> saved.  See <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>, for how to call
+<em>is</em> saved.  See <a href="#Opening and Closing Files">Opening and Closing Files</a>, for how to call
 <code>open</code>.
 
 <p>There are two sorts of options specified by open-time flags.
 
@@ -32136,46 +31463,43 @@
 
 <p>Here are the file name translation flags.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_CREAT</b><i>
-</i></td>
+<td align="left"><code>int <b>O_CREAT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If set, the file will be created if it doesn't already exist. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_EXCL</b><i>
-</i></td>
+<td align="left"><code>int <b>O_EXCL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If both <code>O_CREAT</code> and <code>O_EXCL</code> are set, then <code>open</code> fails
 if the specified file already exists.  This is guaranteed to never
 clobber an existing file. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_NONBLOCK</b><i>
-</i></td>
+<td align="left"><code>int <b>O_NONBLOCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This prevents <code>open</code> from blocking for a "long time" to open the
 file.  This is only meaningful for some kinds of files, usually devices
 such as serial ports; when it is not meaningful, it is harmless and
@@ -32185,26 +31509,25 @@
 
 <p>Note that the <code>O_NONBLOCK</code> flag is overloaded as both an I/O operating
 mode and a file name translation flag.  This means that specifying
 <code>O_NONBLOCK</code> in <code>open</code> also sets nonblocking I/O mode;
-see <a href="#Operating%20Modes">Operating Modes</a>.  To open the file without blocking but do normal
+see <a href="#Operating Modes">Operating Modes</a>.  To open the file without blocking but do normal
 I/O that blocks, you must call <code>open</code> with <code>O_NONBLOCK</code> set and
 then call <code>fcntl</code> to turn the bit off. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_NOCTTY</b><i>
-</i></td>
+<td align="left"><code>int <b>O_NOCTTY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the named file is a terminal device, don't make it the controlling
-terminal for the process.  See <a href="#Job%20Control">Job Control</a>, for information about
+terminal for the process.  See <a href="#Job Control">Job Control</a>, for information about
 what it means to be the controlling terminal.
 
 <p>In the GNU system and 4.4 BSD, opening a file never makes it the
 controlling terminal and <code>O_NOCTTY</code> is zero.  However, other
@@ -32216,49 +31539,46 @@
 
 <p>The following three file name translation flags exist only in the GNU system.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_IGNORE_CTTY</b><i>
-</i></td>
+<td align="left"><code>int <b>O_IGNORE_CTTY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Do not recognize the named file as the controlling terminal, even if it
 refers to the process's existing controlling terminal device.  Operations
 on the new file descriptor will never induce job control signals. 
-See <a href="#Job%20Control">Job Control</a>. 
+See <a href="#Job Control">Job Control</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_NOLINK</b><i>
-</i></td>
+<td align="left"><code>int <b>O_NOLINK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the named file is a symbolic link, open the link itself instead of
 the file it refers to.  (<code>fstat</code> on the new file descriptor will
 return the information returned by <code>lstat</code> on the link's name.) 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_NOTRANS</b><i>
-</i></td>
+<td align="left"><code>int <b>O_NOTRANS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the named file is specially translated, do not invoke the translator. 
 Open the bare file the translator itself sees. 
 </td></tr>
@@ -32269,16 +31589,15 @@
 as part of <code>open</code> instead of in separate calls is that <code>open</code>
 can do them <i>atomically</i>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_TRUNC</b><i>
-</i></td>
+<td align="left"><code>int <b>O_TRUNC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Truncate the file to zero length.  This option is only useful for
 regular files, not special files such as directories or FIFOs.  POSIX.1
 requires that you open the file for writing to use <code>O_TRUNC</code>.  In
@@ -32296,46 +31615,44 @@
 <p>The remaining operating modes are BSD extensions.  They exist only
 on some systems.  On other systems, these macros are not defined.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_SHLOCK</b><i>
-</i></td>
+<td align="left"><code>int <b>O_SHLOCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Acquire a shared lock on the file, as with <code>flock</code>. 
-See <a href="#File%20Locks">File Locks</a>.
+See <a href="#File Locks">File Locks</a>.
 
 <p>If <code>O_CREAT</code> is specified, the locking is done atomically when
 creating the file.  You are guaranteed that no other process will get
 the lock on the new file first. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_EXLOCK</b><i>
-</i></td>
+<td align="left"><code>int <b>O_EXLOCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Acquire an exclusive lock on the file, as with <code>flock</code>. 
-See <a href="#File%20Locks">File Locks</a>.  This is atomic like <code>O_SHLOCK</code>. 
+See <a href="#File Locks">File Locks</a>.  This is atomic like <code>O_SHLOCK</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Operating%20Modes">Operating Modes</a>,
-Next:<a rel=next accesskey=n href="#Getting%20File%20Status%20Flags">Getting File Status Flags</a>,
-Previous:<a rel=previous accesskey=p href="#Open-time%20Flags">Open-time Flags</a>,
-Up:<a rel=up accesskey=u href="#File%20Status%20Flags">File Status Flags</a>
+Node:<a name="Operating Modes">Operating Modes</a>,
+Next:<a rel=next accesskey=n href="#Getting File Status Flags">Getting File Status Flags</a>,
+Previous:<a rel=previous accesskey=p href="#Open-time Flags">Open-time Flags</a>,
+Up:<a rel=up accesskey=u href="#File Status Flags">File Status Flags</a>
 <br>
 
 <h4>I/O Operating Modes</h4>
 
@@ -32343,16 +31660,15 @@
 descriptor work.  These flags are set by <code>open</code> and can be fetched
 and changed with <code>fcntl</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_APPEND</b><i>
-</i></td>
+<td align="left"><code>int <b>O_APPEND</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The bit that enables append mode for the file.  If set, then all
 <code>write</code> operations write the data at the end of the file, extending
 it, regardless of the current file position.  This is the only reliable
@@ -32365,37 +31681,35 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_NONBLOCK</b><i>
-</i></td>
+<td align="left"><code>int <b>O_NONBLOCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The bit that enables nonblocking mode for the file.  If this bit is set,
 <code>read</code> requests on the file can return immediately with a failure
 status if there is no input immediately available, instead of blocking. 
 Likewise, <code>write</code> requests can also return immediately with a
 failure status if the output can't be written immediately.
 
 <p>Note that the <code>O_NONBLOCK</code> flag is overloaded as both an I/O
-operating mode and a file name translation flag; see <a href="#Open-time%20Flags">Open-time Flags</a>. 
+operating mode and a file name translation flag; see <a href="#Open-time Flags">Open-time Flags</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_NDELAY</b><i>
-</i></td>
+<td align="left"><code>int <b>O_NDELAY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an obsolete name for <code>O_NONBLOCK</code>, provided for
 compatibility with BSD.  It is not defined by the POSIX.1 standard. 
 </td></tr>
@@ -32404,33 +31718,31 @@
 <p>The remaining operating modes are BSD and GNU extensions.  They exist only
 on some systems.  On other systems, these macros are not defined.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_ASYNC</b><i>
-</i></td>
+<td align="left"><code>int <b>O_ASYNC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The bit that enables asynchronous input mode.  If set, then <code>SIGIO</code>
-signals will be generated when input is available.  See <a href="#Interrupt%20Input">Interrupt Input</a>.
+signals will be generated when input is available.  See <a href="#Interrupt Input">Interrupt Input</a>.
 
 <p>Asynchronous input mode is a BSD feature. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_FSYNC</b><i>
-</i></td>
+<td align="left"><code>int <b>O_FSYNC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The bit that enables synchronous writing for the file.  If set, each
 <code>write</code> call will make sure the data is reliably stored on disk before
 returning. 
@@ -32438,59 +31750,56 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_SYNC</b><i>
-</i></td>
+<td align="left"><code>int <b>O_SYNC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is another name for <code>O_FSYNC</code>.  They have the same value. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>O_NOATIME</b><i>
-</i></td>
+<td align="left"><code>int <b>O_NOATIME</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, <code>read</code> will not update the access time of the
-file.  See <a href="#File%20Times">File Times</a>.  This is used by programs that do backups, so
+file.  See <a href="#File Times">File Times</a>.  This is used by programs that do backups, so
 that backing a file up does not count as reading it. 
 Only the owner of the file or the superuser may use this bit.
 
 <p>This is a GNU extension. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Getting%20File%20Status%20Flags">Getting File Status Flags</a>,
-Previous:<a rel=previous accesskey=p href="#Operating%20Modes">Operating Modes</a>,
-Up:<a rel=up accesskey=u href="#File%20Status%20Flags">File Status Flags</a>
+Node:<a name="Getting File Status Flags">Getting File Status Flags</a>,
+Previous:<a rel=previous accesskey=p href="#Operating Modes">Operating Modes</a>,
+Up:<a rel=up accesskey=u href="#File Status Flags">File Status Flags</a>
 <br>
 
 <h4>Getting and Setting File Status Flags</h4>
 
 <p>The <code>fcntl</code> function can fetch or change file status flags.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_GETFL</b><i>
-</i></td>
+<td align="left"><code>int <b>F_GETFL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 read the file status flags for the open file with descriptor
 <var>filedes</var>.
@@ -32511,16 +31820,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_SETFL</b><i>
-</i></td>
+<td align="left"><code>int <b>F_SETFL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to set
 the file status flags for the open file corresponding to the
 <var>filedes</var> argument.  This command requires a third <code>int</code>
@@ -32566,12 +31874,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="File%20Locks">File Locks</a>,
-Next:<a rel=next accesskey=n href="#Interrupt%20Input">Interrupt Input</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Status%20Flags">File Status Flags</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Node:<a name="File Locks">File Locks</a>,
+Next:<a rel=next accesskey=n href="#Interrupt Input">Interrupt Input</a>,
+Previous:<a rel=previous accesskey=p href="#File Status Flags">File Status Flags</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>File Locks</h3>
 
@@ -32599,23 +31907,22 @@
 that file is closed by the process, all of the locks that process holds
 on that file are released, even if the locks were made using other
 descriptors that remain open.  Likewise, locks are released when a
 process exits, and are not inherited by child processes created using
-<code>fork</code> (see <a href="#Creating%20a%20Process">Creating a Process</a>).
+<code>fork</code> (see <a href="#Creating a Process">Creating a Process</a>).
 
 <p>When making a lock, use a <code>struct flock</code> to specify what kind of
 lock and where.  This data type and the associated macros for the
 <code>fcntl</code> function are declared in the header file <code>fcntl.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct flock</b><i>
-</i></td>
+<td align="left"><code><b>struct flock</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used with the <code>fcntl</code> function to describe a file
 lock.  It has these members:
 
@@ -32639,24 +31946,23 @@
 <code>0</code> is treated specially; it means the region extends to the end of
 the file.
 
 <br><dt><code>pid_t l_pid</code>
-<dd>This field is the process ID (see <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>) of the
+<dd>This field is the process ID (see <a href="#Process Creation Concepts">Process Creation Concepts</a>) of the
 process holding the lock.  It is filled in by calling <code>fcntl</code> with
 the <code>F_GETLK</code> command, but is ignored when making a lock. 
 </dl>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_GETLK</b><i>
-</i></td>
+<td align="left"><code>int <b>F_GETLK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 specify that it should get information about a lock.  This command
 requires a third argument of type <code>struct&nbsp;flock&nbsp;*</code> to be passed
@@ -32698,16 +32004,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_SETLK</b><i>
-</i></td>
+<td align="left"><code>int <b>F_SETLK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 specify that it should set or clear a lock.  This command requires a
 third argument of type <code>struct&nbsp;flock&nbsp;*</code> to be passed to
@@ -32757,16 +32062,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_SETLKW</b><i>
-</i></td>
+<td align="left"><code>int <b>F_SETLKW</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 specify that it should set or clear a lock.  It is just like the
 <code>F_SETLK</code> command, but causes the process to block (or wait)
@@ -32781,9 +32085,9 @@
 
 <dl>
 <dt><code>EINTR</code>
 <dd>The function was interrupted by a signal while it was waiting. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>EDEADLK</code>
 <dd>The specified region is being locked by another process.  But that
 process is waiting to lock a region which the current process has
@@ -32829,49 +32133,48 @@
 controlling access to a file.  There is still potential for access to
 the file by programs that don't use the lock protocol.
 
 <p><hr>
-Node:<a name="Interrupt%20Input">Interrupt Input</a>,
+Node:<a name="Interrupt Input">Interrupt Input</a>,
 Next:<a rel=next accesskey=n href="#IOCTLs">IOCTLs</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Locks">File Locks</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Previous:<a rel=previous accesskey=p href="#File Locks">File Locks</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Interrupt-Driven Input</h3>
 
 <p>If you set the <code>O_ASYNC</code> status flag on a file descriptor
-(see <a href="#File%20Status%20Flags">File Status Flags</a>), a <code>SIGIO</code> signal is sent whenever
+(see <a href="#File Status Flags">File Status Flags</a>), a <code>SIGIO</code> signal is sent whenever
 input or output becomes possible on that file descriptor.  The process
 or process group to receive the signal can be selected by using the
 <code>F_SETOWN</code> command to the <code>fcntl</code> function.  If the file
 descriptor is a socket, this also selects the recipient of <code>SIGURG</code>
 signals that are delivered when out-of-band data arrives on that socket;
-see <a href="#Out-of-Band%20Data">Out-of-Band Data</a>.  (<code>SIGURG</code> is sent in any situation
+see <a href="#Out-of-Band Data">Out-of-Band Data</a>.  (<code>SIGURG</code> is sent in any situation
 where <code>select</code> would report the socket as having an "exceptional
-condition".  See <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.)
+condition".  See <a href="#Waiting for I%2fO">Waiting for I/O</a>.)
 
 <p>If the file descriptor corresponds to a terminal device, then <code>SIGIO</code>
 signals are sent to the foreground process group of the terminal. 
-See <a href="#Job%20Control">Job Control</a>.
+See <a href="#Job Control">Job Control</a>.
 
 <p>The symbols in this section are defined in the header file
 <code>fcntl.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_GETOWN</b><i>
-</i></td>
+<td align="left"><code>int <b>F_GETOWN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 specify that it should get information about the process or process
 group to which <code>SIGIO</code> signals are sent.  (For a terminal, this is
 actually the foreground process group ID, which you can get using
-<code>tcgetpgrp</code>; see <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>.)
+<code>tcgetpgrp</code>; see <a href="#Terminal Access Functions">Terminal Access Functions</a>.)
 
 <p>The return value is interpreted as a process ID; if negative, its
 absolute value is the process group ID.
 
@@ -32884,16 +32187,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_SETOWN</b><i>
-</i></td>
+<td align="left"><code>int <b>F_SETOWN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used as the <var>command</var> argument to <code>fcntl</code>, to
 specify that it should set the process or process group to which
 <code>SIGIO</code> signals are sent.  This command requires a third argument
@@ -32921,10 +32223,10 @@
 </table>
 
 <p><hr>
 Node:<a name="IOCTLs">IOCTLs</a>,
-Previous:<a rel=previous accesskey=p href="#Interrupt%20Input">Interrupt Input</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20I%2fO">Low-Level I/O</a>
+Previous:<a rel=previous accesskey=p href="#Interrupt Input">Interrupt Input</a>,
+Up:<a rel=up accesskey=u href="#Low-Level I%2fO">Low-Level I/O</a>
 <br>
 
 <h3>Generic I/O Control operations</h3>
 
@@ -32957,16 +32259,15 @@
 <code>sys/ioctl.h</code>.  The code numbers themselves are defined in many
 different headers.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ioctl</b><i> (int <var>filedes</var>, int <var>command</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>ioctl</b><i> (int <var>filedes</var>, int <var>command</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>ioctl</code> function performs the generic I/O operation
 <var>command</var> on <var>filedes</var>.
@@ -32985,62 +32286,62 @@
 unknown device.
 
 <p>Most IOCTLs are OS-specific and/or only used in special system utilities,
 and are thus beyond the scope of this document.  For an example of the use
-of an IOCTL, see <a href="#Out-of-Band%20Data">Out-of-Band Data</a>.
+of an IOCTL, see <a href="#Out-of-Band Data">Out-of-Band Data</a>.
 
 <p><hr>
-Node:<a name="File%20System%20Interface">File System Interface</a>,
-Next:<a rel=next accesskey=n href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>,
-Previous:<a rel=previous accesskey=p href="#Low-Level%20I%2fO">Low-Level I/O</a>,
+Node:<a name="File System Interface">File System Interface</a>,
+Next:<a rel=next accesskey=n href="#Pipes and FIFOs">Pipes and FIFOs</a>,
+Previous:<a rel=previous accesskey=p href="#Low-Level I%2fO">Low-Level I/O</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>File System Interface</h2>
 
 <p>This chapter describes the GNU C library's functions for manipulating
-files.  Unlike the input and output functions (see <a href="#I%2fO%20on%20Streams">I/O on Streams</a>;
-see <a href="#Low-Level%20I%2fO">Low-Level I/O</a>), these functions are concerned with operating
+files.  Unlike the input and output functions (see <a href="#I%2fO on Streams">I/O on Streams</a>;
+see <a href="#Low-Level I%2fO">Low-Level I/O</a>), these functions are concerned with operating
 on the files themselves rather than on their contents.
 
 <p>Among the facilities described in this chapter are functions for
 examining or modifying directories, functions for renaming and deleting
 files, and functions for examining and setting file attributes such as
 access permissions and modification times.
 
 <ul>
-<li><a accesskey=1 href="#Working%20Directory">Working Directory</a>:            This is used to resolve relative
+<li><a accesskey=1 href="#Working Directory">Working Directory</a>:            This is used to resolve relative
 				 file names. 
-<li><a accesskey=2 href="#Accessing%20Directories">Accessing Directories</a>:        Finding out what files a directory
+<li><a accesskey=2 href="#Accessing Directories">Accessing Directories</a>:        Finding out what files a directory
 				 contains. 
-<li><a accesskey=3 href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>:  Apply actions to all files or a selectable
+<li><a accesskey=3 href="#Working with Directory Trees">Working with Directory Trees</a>:  Apply actions to all files or a selectable
                                  subset of a directory hierarchy. 
-<li><a accesskey=4 href="#Hard%20Links">Hard Links</a>:                   Adding alternate names to a file. 
-<li><a accesskey=5 href="#Symbolic%20Links">Symbolic Links</a>:               A file that ``points to'' a file name. 
-<li><a accesskey=6 href="#Deleting%20Files">Deleting Files</a>:               How to delete a file, and what that means. 
-<li><a accesskey=7 href="#Renaming%20Files">Renaming Files</a>:               Changing a file's name. 
-<li><a accesskey=8 href="#Creating%20Directories">Creating Directories</a>:         A system call just for creating a directory. 
-<li><a accesskey=9 href="#File%20Attributes">File Attributes</a>:              Attributes of individual files. 
-<li><a href="#Making%20Special%20Files">Making Special Files</a>:         How to create special files. 
-<li><a href="#Temporary%20Files">Temporary Files</a>:              Naming and creating temporary files. 
+<li><a accesskey=4 href="#Hard Links">Hard Links</a>:                   Adding alternate names to a file. 
+<li><a accesskey=5 href="#Symbolic Links">Symbolic Links</a>:               A file that "points to" a file name. 
+<li><a accesskey=6 href="#Deleting Files">Deleting Files</a>:               How to delete a file, and what that means. 
+<li><a accesskey=7 href="#Renaming Files">Renaming Files</a>:               Changing a file's name. 
+<li><a accesskey=8 href="#Creating Directories">Creating Directories</a>:         A system call just for creating a directory. 
+<li><a accesskey=9 href="#File Attributes">File Attributes</a>:              Attributes of individual files. 
+<li><a href="#Making Special Files">Making Special Files</a>:         How to create special files. 
+<li><a href="#Temporary Files">Temporary Files</a>:              Naming and creating temporary files. 
 </ul>
 
 <p><hr>
-Node:<a name="Working%20Directory">Working Directory</a>,
-Next:<a rel=next accesskey=n href="#Accessing%20Directories">Accessing Directories</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Working Directory">Working Directory</a>,
+Next:<a rel=next accesskey=n href="#Accessing Directories">Accessing Directories</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Working Directory</h3>
 
 <p>Each process has associated with it a directory, called its <dfn>current
 working directory</dfn> or simply <dfn>working directory</dfn>, that is used in
-the resolution of relative file names (see <a href="#File%20Name%20Resolution">File Name Resolution</a>).
+the resolution of relative file names (see <a href="#File Name Resolution">File Name Resolution</a>).
 
 <p>When you log in and begin a new session, your working directory is
 initially set to the home directory associated with your login account
 in the system user database.  You can find any user's home directory
-using the <code>getpwuid</code> or <code>getpwnam</code> functions; see <a href="#User%20Database">User Database</a>.
+using the <code>getpwuid</code> or <code>getpwnam</code> functions; see <a href="#User Database">User Database</a>.
 
 <p>Users can change the working directory using shell commands like
 <code>cd</code>.  The functions described in this section are the primitives
 used by those commands and by other programs for examining and changing
@@ -33049,16 +32350,15 @@
 <p>Prototypes for these functions are declared in the header file
 <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>getcwd</b><i> (char *<var>buffer</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>char * <b>getcwd</b><i> (char *<var>buffer</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getcwd</code> function returns an absolute file name representing
 the current working directory, storing it in the character array
 <var>buffer</var> that you provide.  The <var>size</var> argument is how you tell
@@ -33066,9 +32366,9 @@
 
 <p>The GNU library version of this function also permits you to specify a
 null pointer for the <var>buffer</var> argument.  Then <code>getcwd</code>
 allocates a buffer automatically, as with <code>malloc</code>
-(see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>).  If the <var>size</var> is greater than
+(see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>).  If the <var>size</var> is greater than
 zero, then the buffer is that large; otherwise, the buffer is as large
 as necessary to hold the result.
 
 <p>The return value is <var>buffer</var> on success and a null pointer on failure. 
@@ -33108,43 +32408,41 @@
     }
 }
 </pre>
 
-<p>See <a href="#Malloc%20Examples">Malloc Examples</a>, for information about <code>xmalloc</code>, which is
+<p>See <a href="#Malloc Examples">Malloc Examples</a>, for information about <code>xmalloc</code>, which is
 not a library function but is a customary name used in most GNU
 software.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>getwd</b><i> (char *<var>buffer</var>)
-</i></td>
+<td align="left"><code>char * <b>getwd</b><i> (char *<var>buffer</var>)</i></code></td>
 <td align="right">Deprecated Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>getcwd</code>, but has no way to specify the size of
 the buffer.  The GNU library provides <code>getwd</code> only
 for backwards compatibility with BSD.
 
 <p>The <var>buffer</var> argument should be a pointer to an array at least
-<code>PATH_MAX</code> bytes long (see <a href="#Limits%20for%20Files">Limits for Files</a>).  In the GNU
+<code>PATH_MAX</code> bytes long (see <a href="#Limits for Files">Limits for Files</a>).  In the GNU
 system there is no limit to the size of a file name, so this is not
 necessarily enough space to contain the directory name.  That is why
 this function is deprecated. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>get_current_dir_name</b><i> (void)
-</i></td>
+<td align="left"><code>char * <b>get_current_dir_name</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This <code>get_current_dir_name</code> function is bascially equivalent to
 <code>getcwd&nbsp;(NULL,&nbsp;0)</code>.  The only difference is that the value of
 the <code>PWD</code> variable is returned if this value is correct.  This is a
@@ -33157,37 +32455,35 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>chdir</b><i> (const char *<var>filename</var>)
-</i></td>
+<td align="left"><code>int <b>chdir</b><i> (const char *<var>filename</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to set the process's working directory to
 <var>filename</var>.
 
 <p>The normal, successful return value from <code>chdir</code> is <code>0</code>.  A
 value of <code>-1</code> is returned to indicate an error.  The <code>errno</code>
 error conditions defined for this function are the usual file name
-syntax errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), plus <code>ENOTDIR</code> if the
+syntax errors (see <a href="#File Name Errors">File Name Errors</a>), plus <code>ENOTDIR</code> if the
 file <var>filename</var> is not a directory. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fchdir</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>int <b>fchdir</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to set the process's working directory to
 directory associated with the file descriptor <var>filedes</var>.
 
@@ -33214,12 +32510,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Accessing%20Directories">Accessing Directories</a>,
-Next:<a rel=next accesskey=n href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>,
-Previous:<a rel=previous accesskey=p href="#Working%20Directory">Working Directory</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Accessing Directories">Accessing Directories</a>,
+Next:<a rel=next accesskey=n href="#Working with Directory Trees">Working with Directory Trees</a>,
+Previous:<a rel=previous accesskey=p href="#Working Directory">Working Directory</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Accessing Directories</h3>
 
@@ -33232,26 +32528,26 @@
 the directory stream to retrieve these entries, represented as
 <code>struct&nbsp;dirent</code> objects.  The name of the file for each entry is
 stored in the <code>d_name</code> member of this structure.  There are obvious
 parallels here to the stream facilities for ordinary files, described in
-<a href="#I%2fO%20on%20Streams">I/O on Streams</a>.
+<a href="#I%2fO on Streams">I/O on Streams</a>.
 
 <ul>
-<li><a accesskey=1 href="#Directory%20Entries">Directory Entries</a>:            Format of one directory entry. 
-<li><a accesskey=2 href="#Opening%20a%20Directory">Opening a Directory</a>:          How to open a directory stream. 
-<li><a accesskey=3 href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>:    How to read directory entries from the stream. 
-<li><a accesskey=4 href="#Simple%20Directory%20Lister">Simple Directory Lister</a>:      A very simple directory listing program. 
-<li><a accesskey=5 href="#Random%20Access%20Directory">Random Access Directory</a>:      Rereading part of the directory
+<li><a accesskey=1 href="#Directory Entries">Directory Entries</a>:            Format of one directory entry. 
+<li><a accesskey=2 href="#Opening a Directory">Opening a Directory</a>:          How to open a directory stream. 
+<li><a accesskey=3 href="#Reading%2fClosing Directory">Reading/Closing Directory</a>:    How to read directory entries from the stream. 
+<li><a accesskey=4 href="#Simple Directory Lister">Simple Directory Lister</a>:      A very simple directory listing program. 
+<li><a accesskey=5 href="#Random Access Directory">Random Access Directory</a>:      Rereading part of the directory
                                  already read with the same stream. 
-<li><a accesskey=6 href="#Scanning%20Directory%20Content">Scanning Directory Content</a>:   Get entries for user selected subset of
+<li><a accesskey=6 href="#Scanning Directory Content">Scanning Directory Content</a>:   Get entries for user selected subset of
                                  contents in given directory. 
-<li><a accesskey=7 href="#Simple%20Directory%20Lister%20Mark%20II">Simple Directory Lister Mark II</a>:   Revised version of the program. 
+<li><a accesskey=7 href="#Simple Directory Lister Mark II">Simple Directory Lister Mark II</a>:   Revised version of the program. 
 </ul>
 
 <p><hr>
-Node:<a name="Directory%20Entries">Directory Entries</a>,
-Next:<a rel=next accesskey=n href="#Opening%20a%20Directory">Opening a Directory</a>,
-Up:<a rel=up accesskey=u href="#Accessing%20Directories">Accessing Directories</a>
+Node:<a name="Directory Entries">Directory Entries</a>,
+Next:<a rel=next accesskey=n href="#Opening a Directory">Opening a Directory</a>,
+Up:<a rel=up accesskey=u href="#Accessing Directories">Accessing Directories</a>
 <br>
 
 <h4>Format of a Directory Entry</h4>
 
@@ -33259,16 +32555,15 @@
 might obtain it from a directory stream.  All the symbols are declared
 in the header file <code>dirent.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct dirent</b><i>
-</i></td>
+<td align="left"><code><b>struct dirent</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a structure type used to return information about directory
 entries.  It contains the following fields:
 
@@ -33280,9 +32575,9 @@
 <br><dt><code>ino_t d_fileno</code>
 <dd>This is the file serial number.  For BSD compatibility, you can also
 refer to this member as <code>d_ino</code>.  In the GNU system and most POSIX
 systems, for most files this the same as the <code>st_ino</code> member that
-<code>stat</code> will return for the file.  See <a href="#File%20Attributes">File Attributes</a>.
+<code>stat</code> will return for the file.  See <a href="#File Attributes">File Attributes</a>.
 
 <br><dt><code>unsigned char d_namlen</code>
 <dd>This is the length of the file name, not including the terminating null
 character.  Its type is <code>unsigned char</code> because that is the integer
@@ -33302,9 +32597,9 @@
 <br><dt><code>DT_DIR</code>
 <dd>A directory.
 
 <br><dt><code>DT_FIFO</code>
-<dd>A named pipe, or FIFO.  See <a href="#FIFO%20Special%20Files">FIFO Special Files</a>.
+<dd>A named pipe, or FIFO.  See <a href="#FIFO Special Files">FIFO Special Files</a>.
 
 <br><dt><code>DT_SOCK</code>
 <dd>A local-domain socket.  
 <br><dt><code>DT_CHR</code>
@@ -33321,30 +32616,28 @@
 value is DT_UNKNOWN.  These two macros convert between <code>d_type</code>
 values and <code>st_mode</code> values:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>IFTODT</b><i> (mode_t <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>IFTODT</b><i> (mode_t <var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This returns the <code>d_type</code> value corresponding to <var>mode</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">mode_t <b>DTTOIF</b><i> (int <var>dtype</var>)
-</i></td>
+<td align="left"><code>mode_t <b>DTTOIF</b><i> (int <var>dtype</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This returns the <code>st_mode</code> value corresponding to <var>dtype</var>. 
 </td></tr>
 </table>
@@ -33362,33 +32655,32 @@
 single file is that they have the same value for the <code>d_fileno</code>
 field.
 
 <p>File attributes such as size, modification times etc., are part of the
-file itself, not of any particular directory entry.  See <a href="#File%20Attributes">File Attributes</a>. 
+file itself, not of any particular directory entry.  See <a href="#File Attributes">File Attributes</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Opening%20a%20Directory">Opening a Directory</a>,
-Next:<a rel=next accesskey=n href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>,
-Previous:<a rel=previous accesskey=p href="#Directory%20Entries">Directory Entries</a>,
-Up:<a rel=up accesskey=u href="#Accessing%20Directories">Accessing Directories</a>
+Node:<a name="Opening a Directory">Opening a Directory</a>,
+Next:<a rel=next accesskey=n href="#Reading%2fClosing Directory">Reading/Closing Directory</a>,
+Previous:<a rel=previous accesskey=p href="#Directory Entries">Directory Entries</a>,
+Up:<a rel=up accesskey=u href="#Accessing Directories">Accessing Directories</a>
 <br>
 
 <h4>Opening a Directory Stream</h4>
 
 <p>This section describes how to open a directory stream.  All the symbols
 are declared in the header file <code>dirent.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>DIR</b><i>
-</i></td>
+<td align="left"><code><b>DIR</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>DIR</code> data type represents a directory stream. 
 </td></tr>
 </table>
@@ -33398,23 +32690,22 @@
 you.  Instead, you refer to these objects using the pointers returned by
 the following functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">DIR * <b>opendir</b><i> (const char *<var>dirname</var>)
-</i></td>
+<td align="left"><code>DIR * <b>opendir</b><i> (const char *<var>dirname</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>opendir</code> function opens and returns a directory stream for
 reading the directory whose file name is <var>dirname</var>.  The stream has
 type <code>DIR *</code>.
 
 <p>If unsuccessful, <code>opendir</code> returns a null pointer.  In addition to
-the usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the
+the usual file name errors (see <a href="#File Name Errors">File Name Errors</a>), the
 following <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -33430,10 +32721,10 @@
 </dl>
 
 <p>The <code>DIR</code> type is typically implemented using a file descriptor,
 and the <code>opendir</code> function in terms of the <code>open</code> function. 
-See <a href="#Low-Level%20I%2fO">Low-Level I/O</a>.  Directory streams and the underlying
-file descriptors are closed on <code>exec</code> (see <a href="#Executing%20a%20File">Executing a File</a>). 
+See <a href="#Low-Level I%2fO">Low-Level I/O</a>.  Directory streams and the underlying
+file descriptors are closed on <code>exec</code> (see <a href="#Executing a File">Executing a File</a>). 
 </td></tr>
 </table>
 
 <p>In some situations it can be desirable to get hold of the file
@@ -33444,16 +32735,15 @@
 in the GNU C library.  Instead a separate function is provided to allow
 access.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>dirfd</b><i> (DIR *<var>dirstream</var>)
-</i></td>
+<td align="left"><code>int <b>dirfd</b><i> (DIR *<var>dirstream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>dirfd</code> returns the file descriptor associated with
 the directory stream <var>dirstream</var>.  This descriptor can be used until
 the directory is closed with <code>closedir</code>.  If the directory stream
@@ -33462,12 +32752,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Reading%2fClosing%20Directory">Reading/Closing Directory</a>,
-Next:<a rel=next accesskey=n href="#Simple%20Directory%20Lister">Simple Directory Lister</a>,
-Previous:<a rel=previous accesskey=p href="#Opening%20a%20Directory">Opening a Directory</a>,
-Up:<a rel=up accesskey=u href="#Accessing%20Directories">Accessing Directories</a>
+Node:<a name="Reading%2fClosing Directory">Reading/Closing Directory</a>,
+Next:<a rel=next accesskey=n href="#Simple Directory Lister">Simple Directory Lister</a>,
+Previous:<a rel=previous accesskey=p href="#Opening a Directory">Opening a Directory</a>,
+Up:<a rel=up accesskey=u href="#Accessing Directories">Accessing Directories</a>
 <br>
 
 <h4>Reading and Closing a Directory Stream</h4>
 
@@ -33475,25 +32765,24 @@
 stream, and how to close the stream when you are done with it.  All the
 symbols are declared in the header file <code>dirent.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct dirent * <b>readdir</b><i> (DIR *<var>dirstream</var>)
-</i></td>
+<td align="left"><code>struct dirent * <b>readdir</b><i> (DIR *<var>dirstream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads the next entry from the directory.  It normally
 returns a pointer to a structure containing information about the file. 
 This structure is statically allocated and can be rewritten by a
 subsequent call.
 
 <p><strong>Portability Note:</strong> On some systems <code>readdir</code> may not
 return entries for <code>.</code> and <code>..</code>, even though these are always
-valid file names in any directory.  See <a href="#File%20Name%20Resolution">File Name Resolution</a>.
+valid file names in any directory.  See <a href="#File Name Resolution">File Name Resolution</a>.
 
 <p>If there are no more entries in the directory or an error is detected,
 <code>readdir</code> returns a null pointer.  The following <code>errno</code> error
 conditions are defined for this function:
@@ -33509,16 +32798,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>readdir_r</b><i> (DIR *<var>dirstream</var>, struct dirent *<var>entry</var>, struct dirent **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>readdir_r</b><i> (DIR *<var>dirstream</var>, struct dirent *<var>entry</var>, struct dirent **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is the reentrant version of <code>readdir</code>.  Like
 <code>readdir</code> it returns the next entry from the directory.  But to
 prevent conflicts between simultaneously running threads the result is
@@ -33567,16 +32855,15 @@
 <p>To support large filesystems on 32-bit machines there are LFS variants
 of the last two functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct dirent64 * <b>readdir64</b><i> (DIR *<var>dirstream</var>)
-</i></td>
+<td align="left"><code>struct dirent64 * <b>readdir64</b><i> (DIR *<var>dirstream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>readdir64</code> function is just like the <code>readdir</code> function
 except that it returns a pointer to a record of type <code>struct
 dirent64</code>.  Some of the members of this data type (notably <code>d_ino</code>)
@@ -33586,16 +32873,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>readdir64_r</b><i> (DIR *<var>dirstream</var>, struct dirent64 *<var>entry</var>, struct dirent64 **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>readdir64_r</b><i> (DIR *<var>dirstream</var>, struct dirent64 *<var>entry</var>, struct dirent64 **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>readdir64_r</code> function is equivalent to the <code>readdir_r</code>
 function except that it takes parameters of base type <code>struct
 dirent64</code> instead of <code>struct dirent</code> in the second and third
@@ -33604,16 +32890,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>closedir</b><i> (DIR *<var>dirstream</var>)
-</i></td>
+<td align="left"><code>int <b>closedir</b><i> (DIR *<var>dirstream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the directory stream <var>dirstream</var>.  It returns
 <code>0</code> on success and <code>-1</code> on failure.
 
@@ -33627,12 +32912,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Simple%20Directory%20Lister">Simple Directory Lister</a>,
-Next:<a rel=next accesskey=n href="#Random%20Access%20Directory">Random Access Directory</a>,
-Previous:<a rel=previous accesskey=p href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>,
-Up:<a rel=up accesskey=u href="#Accessing%20Directories">Accessing Directories</a>
+Node:<a name="Simple Directory Lister">Simple Directory Lister</a>,
+Next:<a rel=next accesskey=n href="#Random Access Directory">Random Access Directory</a>,
+Previous:<a rel=previous accesskey=p href="#Reading%2fClosing Directory">Reading/Closing Directory</a>,
+Up:<a rel=up accesskey=u href="#Accessing Directories">Accessing Directories</a>
 <br>
 
 <h4>Simple Program to List a Directory</h4>
 
@@ -33668,15 +32953,15 @@
 
 <p>The order in which files appear in a directory tends to be fairly
 random.  A more useful program would sort the entries (perhaps by
 alphabetizing them) before printing them; see
-<a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>, and <a href="#Array%20Sort%20Function">Array Sort Function</a>.
+<a href="#Scanning Directory Content">Scanning Directory Content</a>, and <a href="#Array Sort Function">Array Sort Function</a>.
 
 <p><hr>
-Node:<a name="Random%20Access%20Directory">Random Access Directory</a>,
-Next:<a rel=next accesskey=n href="#Scanning%20Directory%20Content">Scanning Directory Content</a>,
-Previous:<a rel=previous accesskey=p href="#Simple%20Directory%20Lister">Simple Directory Lister</a>,
-Up:<a rel=up accesskey=u href="#Accessing%20Directories">Accessing Directories</a>
+Node:<a name="Random Access Directory">Random Access Directory</a>,
+Next:<a rel=next accesskey=n href="#Scanning Directory Content">Scanning Directory Content</a>,
+Previous:<a rel=previous accesskey=p href="#Simple Directory Lister">Simple Directory Lister</a>,
+Up:<a rel=up accesskey=u href="#Accessing Directories">Accessing Directories</a>
 <br>
 
 <h4>Random Access in a Directory Stream</h4>
 
@@ -33684,16 +32969,15 @@
 already read from an open directory stream.  All the symbols are
 declared in the header file <code>dirent.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>rewinddir</b><i> (DIR *<var>dirstream</var>)
-</i></td>
+<td align="left"><code>void <b>rewinddir</b><i> (DIR *<var>dirstream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>rewinddir</code> function is used to reinitialize the directory
 stream <var>dirstream</var>, so that if you call <code>readdir</code> it
 returns information about the first entry in the directory again.  This
@@ -33705,32 +32989,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">off_t <b>telldir</b><i> (DIR *<var>dirstream</var>)
-</i></td>
+<td align="left"><code>off_t <b>telldir</b><i> (DIR *<var>dirstream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>telldir</code> function returns the file position of the directory
 stream <var>dirstream</var>.  You can use this value with <code>seekdir</code> to
 restore the directory stream to that position. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>seekdir</b><i> (DIR *<var>dirstream</var>, off_t <var>pos</var>)
-</i></td>
+<td align="left"><code>void <b>seekdir</b><i> (DIR *<var>dirstream</var>, off_t <var>pos</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>seekdir</code> function sets the file position of the directory
 stream <var>dirstream</var> to <var>pos</var>.  The value <var>pos</var> must be the
 result of a previous call to <code>telldir</code> on this particular stream;
@@ -33739,12 +33021,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Scanning%20Directory%20Content">Scanning Directory Content</a>,
-Next:<a rel=next accesskey=n href="#Simple%20Directory%20Lister%20Mark%20II">Simple Directory Lister Mark II</a>,
-Previous:<a rel=previous accesskey=p href="#Random%20Access%20Directory">Random Access Directory</a>,
-Up:<a rel=up accesskey=u href="#Accessing%20Directories">Accessing Directories</a>
+Node:<a name="Scanning Directory Content">Scanning Directory Content</a>,
+Next:<a rel=next accesskey=n href="#Simple Directory Lister Mark II">Simple Directory Lister Mark II</a>,
+Previous:<a rel=previous accesskey=p href="#Random Access Directory">Random Access Directory</a>,
+Up:<a rel=up accesskey=u href="#Accessing Directories">Accessing Directories</a>
 <br>
 
 <h4>Scanning the Content of a Directory</h4>
 
@@ -33753,16 +33035,15 @@
 entries in a directory, possibly sort them and get a list of names as
 the result.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>scandir</b><i> (const char *<var>dir</var>, struct dirent ***<var>namelist</var>, int (*<var>selector</var>) (const struct dirent *), int (*<var>cmp</var>) (const void *, const void *))
-</i></td>
+<td align="left"><code>int <b>scandir</b><i> (const char *<var>dir</var>, struct dirent ***<var>namelist</var>, int (*<var>selector</var>) (const struct dirent *), int (*<var>cmp</var>) (const void *, const void *))</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>scandir</code> function scans the contents of the directory selected
 by <var>dir</var>.  The result in *<var>namelist</var> is an array of pointers to
@@ -33791,19 +33072,18 @@
 programmer the GNU C library contains implementations of functions which
 are very helpful for this purpose.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>alphasort</b><i> (const void *<var>a</var>, const void *<var>b</var>)
-</i></td>
+<td align="left"><code>int <b>alphasort</b><i> (const void *<var>a</var>, const void *<var>b</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>alphasort</code> function behaves like the <code>strcoll</code> function
-(see <a href="#String%2fArray%20Comparison">String/Array Comparison</a>).  The difference is that the arguments
+(see <a href="#String%2fArray Comparison">String/Array Comparison</a>).  The difference is that the arguments
 are not string pointers but instead they are of type
 <code>struct dirent **</code>.
 
 <p>The return value of <code>alphasort</code> is less than, equal to, or greater
@@ -33811,16 +33091,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>versionsort</b><i> (const void *<var>a</var>, const void *<var>b</var>)
-</i></td>
+<td align="left"><code>int <b>versionsort</b><i> (const void *<var>a</var>, const void *<var>b</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>versionsort</code> function is like <code>alphasort</code> except that it
 uses the <code>strverscmp</code> function internally. 
 </td></tr>
@@ -33830,16 +33109,15 @@
 anymore since the <code>dirent</code> structure might not able to contain all
 the information.  The LFS provides the new type <code>struct&nbsp;dirent64</code>.  To use this we need a new function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>scandir64</b><i> (const char *<var>dir</var>, struct dirent64 ***<var>namelist</var>, int (*<var>selector</var>) (const struct dirent64 *), int (*<var>cmp</var>) (const void *, const void *))
-</i></td>
+<td align="left"><code>int <b>scandir64</b><i> (const char *<var>dir</var>, struct dirent64 ***<var>namelist</var>, int (*<var>selector</var>) (const struct dirent64 *), int (*<var>cmp</var>) (const void *, const void *))</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>scandir64</code> function works like the <code>scandir</code> function
 except that the directory entries it returns are described by elements
 of type <code>struct&nbsp;dirent64</code>.  The function pointed to by
@@ -33856,19 +33134,18 @@
 <code>alphasort</code> and <code>versionsort</code> cannot be supplied for that
 argument.  Instead we provide the two replacement functions below.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>alphasort64</b><i> (const void *<var>a</var>, const void *<var>b</var>)
-</i></td>
+<td align="left"><code>int <b>alphasort64</b><i> (const void *<var>a</var>, const void *<var>b</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>alphasort64</code> function behaves like the <code>strcoll</code> function
-(see <a href="#String%2fArray%20Comparison">String/Array Comparison</a>).  The difference is that the arguments
+(see <a href="#String%2fArray Comparison">String/Array Comparison</a>).  The difference is that the arguments
 are not string pointers but instead they are of type
 <code>struct dirent64 **</code>.
 
 <p>Return value of <code>alphasort64</code> is less than, equal to, or greater
@@ -33876,16 +33153,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>versionsort64</b><i> (const void *<var>a</var>, const void *<var>b</var>)
-</i></td>
+<td align="left"><code>int <b>versionsort64</b><i> (const void *<var>a</var>, const void *<var>b</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>versionsort64</code> function is like <code>alphasort64</code>, excepted that it
 uses the <code>strverscmp</code> function internally. 
 </td></tr>
@@ -33895,17 +33171,17 @@
 comparison functions or vice versa.  There are systems on which this
 works but on others it will fail miserably.
 
 <p><hr>
-Node:<a name="Simple%20Directory%20Lister%20Mark%20II">Simple Directory Lister Mark II</a>,
-Previous:<a rel=previous accesskey=p href="#Scanning%20Directory%20Content">Scanning Directory Content</a>,
-Up:<a rel=up accesskey=u href="#Accessing%20Directories">Accessing Directories</a>
+Node:<a name="Simple Directory Lister Mark II">Simple Directory Lister Mark II</a>,
+Previous:<a rel=previous accesskey=p href="#Scanning Directory Content">Scanning Directory Content</a>,
+Up:<a rel=up accesskey=u href="#Accessing Directories">Accessing Directories</a>
 <br>
 
 <h4>Simple Program to List a Directory, Mark II</h4>
 
 <p>Here is a revised version of the directory lister found above
-(see <a href="#Simple%20Directory%20Lister">Simple Directory Lister</a>).  Using the <code>scandir</code> function we
+(see <a href="#Simple Directory Lister">Simple Directory Lister</a>).  Using the <code>scandir</code> function we
 can avoid the functions which work directly with the directory contents. 
 After the call the returned entries are available for direct use.
 
 <br><pre>
@@ -33942,12 +33218,12 @@
 <p>Note the simple selector function in this example.  Since we want to see
 all directory entries we always return <code>1</code>.
 
 <p><hr>
-Node:<a name="Working%20with%20Directory%20Trees">Working with Directory Trees</a>,
-Next:<a rel=next accesskey=n href="#Hard%20Links">Hard Links</a>,
-Previous:<a rel=previous accesskey=p href="#Accessing%20Directories">Accessing Directories</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Working with Directory Trees">Working with Directory Trees</a>,
+Next:<a rel=next accesskey=n href="#Hard Links">Hard Links</a>,
+Previous:<a rel=previous accesskey=p href="#Accessing Directories">Accessing Directories</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Working with Directory Trees</h3>
 
@@ -33966,16 +33242,15 @@
 functions take as one of their arguments a pointer to a callback
 function of the appropriate type.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__ftw_func_t</b><i>
-</i></td>
+<td align="left"><code><b>__ftw_func_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <br><pre>int (*) (const char *, const struct stat *, int)
 </pre>
@@ -34018,16 +33293,15 @@
 <p>For the LFS interface and for use in the function <code>ftw64</code>, the
 header <code>ftw.h</code> defines another function type.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__ftw64_func_t</b><i>
-</i></td>
+<td align="left"><code><b>__ftw64_func_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <br><pre>int (*) (const char *, const struct stat64 *, int)
 </pre>
@@ -34039,16 +33313,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__nftw_func_t</b><i>
-</i></td>
+<td align="left"><code><b>__nftw_func_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <br><pre>int (*) (const char *, const struct stat *, int, struct FTW *)
 </pre>
@@ -34078,16 +33351,15 @@
 <p>For the LFS interface there is also a variant of this data type
 available which has to be used with the <code>nftw64</code> function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>__nftw64_func_t</b><i>
-</i></td>
+<td align="left"><code><b>__nftw64_func_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <br><pre>int (*) (const char *, const struct stat64 *, int, struct FTW *)
 </pre>
@@ -34099,16 +33371,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct FTW</b><i>
-</i></td>
+<td align="left"><code><b>struct FTW</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The information contained in this structure helps in interpreting the
 name parameter and gives some information about the current state of the
 traversal of the directory hierarchy.
@@ -34130,16 +33401,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ftw</b><i> (const char *<var>filename</var>, __ftw_func_t <var>func</var>, int <var>descriptors</var>)
-</i></td>
+<td align="left"><code>int <b>ftw</b><i> (const char *<var>filename</var>, __ftw_func_t <var>func</var>, int <var>descriptors</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ftw</code> function calls the callback function given in the
 parameter <var>func</var> for every item which is found in the directory
 specified by <var>filename</var> and all directories below.  The function
@@ -34188,16 +33458,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ftw64</b><i> (const char *<var>filename</var>, __ftw64_func_t <var>func</var>, int <var>descriptors</var>)
-</i></td>
+<td align="left"><code>int <b>ftw64</b><i> (const char *<var>filename</var>, __ftw64_func_t <var>func</var>, int <var>descriptors</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>ftw</code> but it can work on filesystems
 with large files.  File information is reported using a variable of type
 <code>struct stat64</code> which is passed by reference to the callback
@@ -34209,16 +33478,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>nftw</b><i> (const char *<var>filename</var>, __nftw_func_t <var>func</var>, int <var>descriptors</var>, int <var>flag</var>)
-</i></td>
+<td align="left"><code>int <b>nftw</b><i> (const char *<var>filename</var>, __nftw_func_t <var>func</var>, int <var>descriptors</var>, int <var>flag</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>nftw</code> function works like the <code>ftw</code> functions.  They call
 the callback function <var>func</var> for all items found in the directory
 <var>filename</var> and below.  At most <var>descriptors</var> file descriptors
@@ -34266,16 +33534,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>nftw64</b><i> (const char *<var>filename</var>, __nftw64_func_t <var>func</var>, int <var>descriptors</var>, int <var>flag</var>)
-</i></td>
+<td align="left"><code>int <b>nftw64</b><i> (const char *<var>filename</var>, __nftw64_func_t <var>func</var>, int <var>descriptors</var>, int <var>flag</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>nftw</code> but it can work on filesystems
 with large files.  File information is reported using a variable of type
 <code>struct stat64</code> which is passed by reference to the callback
@@ -34287,12 +33554,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Hard%20Links">Hard Links</a>,
-Next:<a rel=next accesskey=n href="#Symbolic%20Links">Symbolic Links</a>,
-Previous:<a rel=previous accesskey=p href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Hard Links">Hard Links</a>,
+Next:<a rel=next accesskey=n href="#Symbolic Links">Symbolic Links</a>,
+Previous:<a rel=previous accesskey=p href="#Working with Directory Trees">Working with Directory Trees</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Hard Links</h3>
 
@@ -34317,23 +33584,22 @@
 <p>The prototype for the <code>link</code> function is declared in the header
 file <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>link</b><i> (const char *<var>oldname</var>, const char *<var>newname</var>)
-</i></td>
+<td align="left"><code>int <b>link</b><i> (const char *<var>oldname</var>, const char *<var>newname</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>link</code> function makes a new link to the existing file named by
 <var>oldname</var>, under the new name <var>newname</var>.
 
 <p>This function returns a value of <code>0</code> if it is successful and
 <code>-1</code> on failure.  In addition to the usual file name errors
-(see <a href="#File%20Name%20Errors">File Name Errors</a>) for both <var>oldname</var> and <var>newname</var>, the
+(see <a href="#File Name Errors">File Name Errors</a>) for both <var>oldname</var> and <var>newname</var>, the
 following <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -34346,9 +33612,9 @@
 
 <br><dt><code>EMLINK</code>
 <dd>There are already too many links to the file named by <var>oldname</var>. 
 (The maximum number of links to a file is <code>LINK_MAX</code>; see
-<a href="#Limits%20for%20Files">Limits for Files</a>.)
+<a href="#Limits for Files">Limits for Files</a>.)
 
 <br><dt><code>ENOENT</code>
 <dd>The file named by <var>oldname</var> doesn't exist.  You can't make a link to
 a file that doesn't exist.
@@ -34376,12 +33642,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Symbolic%20Links">Symbolic Links</a>,
-Next:<a rel=next accesskey=n href="#Deleting%20Files">Deleting Files</a>,
-Previous:<a rel=previous accesskey=p href="#Hard%20Links">Hard Links</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Symbolic Links">Symbolic Links</a>,
+Next:<a rel=next accesskey=n href="#Deleting Files">Deleting Files</a>,
+Previous:<a rel=previous accesskey=p href="#Hard Links">Hard Links</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Symbolic Links</h3>
 
@@ -34413,16 +33679,15 @@
 how many symbolic links are followed when resolving a path name.  The
 limit if it exists is published in the <code>sys/param.h</code> header file.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MAXSYMLINKS</b><i>
-</i></td>
+<td align="left"><code>int <b>MAXSYMLINKS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The macro <code>MAXSYMLINKS</code> specifies how many symlinks some function
 will follow before returning <code>ELOOP</code>.  Not all functions behave the
@@ -34436,23 +33701,22 @@
 <p>Prototypes for most of the functions listed in this section are in
 <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>symlink</b><i> (const char *<var>oldname</var>, const char *<var>newname</var>)
-</i></td>
+<td align="left"><code>int <b>symlink</b><i> (const char *<var>oldname</var>, const char *<var>newname</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>symlink</code> function makes a symbolic link to <var>oldname</var> named
 <var>newname</var>.
 
 <p>The normal return value from <code>symlink</code> is <code>0</code>.  A return value
 of <code>-1</code> indicates an error.  In addition to the usual file name
-syntax errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following <code>errno</code>
+syntax errors (see <a href="#File Name Errors">File Name Errors</a>), the following <code>errno</code>
 error conditions are defined for this function:
 
 <dl>
 <dt><code>EEXIST</code>
@@ -34471,16 +33735,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>readlink</b><i> (const char *<var>filename</var>, char *<var>buffer</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>readlink</b><i> (const char *<var>filename</var>, char *<var>buffer</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>readlink</code> function gets the value of the symbolic link
 <var>filename</var>.  The file name that the link points to is copied into
 <var>buffer</var>.  This file name string is <em>not</em> null-terminated;
@@ -34511,9 +33774,9 @@
 }
 </pre>
 
 <p>A value of <code>-1</code> is returned in case of error.  In addition to the
-usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following
+usual file name errors (see <a href="#File Name Errors">File Name Errors</a>), the following
 <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EINVAL</code>
@@ -34531,16 +33794,15 @@
 instance desirable if files have to be compare in which case different
 names can refer to the same inode.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>canonicalize_file_name</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>char * <b>canonicalize_file_name</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>canonicalize_file_name</code> function returns the absolute name of
 the file named by <var>name</var> which contains no <code>.</code>, <code>..</code>
@@ -34580,16 +33842,15 @@
 <code>canonicalize_file_name</code> in that the user has to provide the buffer
 where the result is placed in.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>realpath</b><i> (const char *restrict <var>name</var>, char *restrict <var>resolved</var>)
-</i></td>
+<td align="left"><code>char * <b>realpath</b><i> (const char *restrict <var>name</var>, char *restrict <var>resolved</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>realpath</code> function behaves just like
 <code>canonicalize_file_name</code> but instead of allocating a buffer for the
@@ -34608,31 +33869,30 @@
 available.  The drawback is that it reports failures for long path on
 systems which have no limits on the file name length.
 
 <p><hr>
-Node:<a name="Deleting%20Files">Deleting Files</a>,
-Next:<a rel=next accesskey=n href="#Renaming%20Files">Renaming Files</a>,
-Previous:<a rel=previous accesskey=p href="#Symbolic%20Links">Symbolic Links</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Deleting Files">Deleting Files</a>,
+Next:<a rel=next accesskey=n href="#Renaming Files">Renaming Files</a>,
+Previous:<a rel=previous accesskey=p href="#Symbolic Links">Symbolic Links</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Deleting Files</h3>
 
 <p>You can delete a file with <code>unlink</code> or <code>remove</code>.
 
 <p>Deletion actually deletes a file name.  If this is the file's only name,
 then the file is deleted as well.  If the file has other remaining names
-(see <a href="#Hard%20Links">Hard Links</a>), it remains accessible under those names.
+(see <a href="#Hard Links">Hard Links</a>), it remains accessible under those names.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>unlink</b><i> (const char *<var>filename</var>)
-</i></td>
+<td align="left"><code>int <b>unlink</b><i> (const char *<var>filename</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>unlink</code> function deletes the file name <var>filename</var>.  If
 this is a file's sole name, the file itself is also deleted.  (Actually,
 if any process has the file open when this happens, deletion is
@@ -34641,9 +33901,9 @@
 <p>The function <code>unlink</code> is declared in the header file <code>unistd.h</code>.
 
 <p>This function returns <code>0</code> on successful completion, and <code>-1</code>
 on error.  In addition to the usual file name errors
-(see <a href="#File%20Name%20Errors">File Name Errors</a>), the following <code>errno</code> error conditions are
+(see <a href="#File Name Errors">File Name Errors</a>), the following <code>errno</code> error conditions are
 defined for this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -34672,16 +33932,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>rmdir</b><i> (const char *<var>filename</var>)
-</i></td>
+<td align="left"><code>int <b>rmdir</b><i> (const char *<var>filename</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>rmdir</code> function deletes a directory.  The directory must be
 empty before it can be removed; in other words, it can only contain
 entries for <code>.</code> and <code>..</code>.
@@ -34704,43 +33963,41 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>remove</b><i> (const char *<var>filename</var>)
-</i></td>
+<td align="left"><code>int <b>remove</b><i> (const char *<var>filename</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the ISO&nbsp;C function to remove a file.  It works like
 <code>unlink</code> for files and like <code>rmdir</code> for directories. 
 <code>remove</code> is declared in <code>stdio.h</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Renaming%20Files">Renaming Files</a>,
-Next:<a rel=next accesskey=n href="#Creating%20Directories">Creating Directories</a>,
-Previous:<a rel=previous accesskey=p href="#Deleting%20Files">Deleting Files</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Renaming Files">Renaming Files</a>,
+Next:<a rel=next accesskey=n href="#Creating Directories">Creating Directories</a>,
+Previous:<a rel=previous accesskey=p href="#Deleting Files">Deleting Files</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Renaming Files</h3>
 
 <p>The <code>rename</code> function is used to change a file's name.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>rename</b><i> (const char *<var>oldname</var>, const char *<var>newname</var>)
-</i></td>
+<td align="left"><code>int <b>rename</b><i> (const char *<var>oldname</var>, const char *<var>newname</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>rename</code> function renames the file <var>oldname</var> to
 <var>newname</var>.  The file formerly accessible under the name
 <var>oldname</var> is afterwards accessible as <var>newname</var> instead.  (If
@@ -34775,9 +34032,9 @@
 operation, it is possible for both names to still exist; but
 <var>newname</var> will always be intact if it exists at all.
 
 <p>If <code>rename</code> fails, it returns <code>-1</code>.  In addition to the usual
-file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following
+file name errors (see <a href="#File Name Errors">File Name Errors</a>), the following
 <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -34824,39 +34081,38 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Creating%20Directories">Creating Directories</a>,
-Next:<a rel=next accesskey=n href="#File%20Attributes">File Attributes</a>,
-Previous:<a rel=previous accesskey=p href="#Renaming%20Files">Renaming Files</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Creating Directories">Creating Directories</a>,
+Next:<a rel=next accesskey=n href="#File Attributes">File Attributes</a>,
+Previous:<a rel=previous accesskey=p href="#Renaming Files">Renaming Files</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Creating Directories</h3>
 
 <p>Directories are created with the <code>mkdir</code> function.  (There is also
 a shell command <code>mkdir</code> which does the same thing.)
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mkdir</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>mkdir</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mkdir</code> function creates a new, empty directory with name
 <var>filename</var>.
 
 <p>The argument <var>mode</var> specifies the file permissions for the new
-directory file.  See <a href="#Permission%20Bits">Permission Bits</a>, for more information about
+directory file.  See <a href="#Permission Bits">Permission Bits</a>, for more information about
 this.
 
 <p>A return value of <code>0</code> indicates successful completion, and
 <code>-1</code> indicates failure.  In addition to the usual file name syntax
-errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following <code>errno</code> error
+errors (see <a href="#File Name Errors">File Name Errors</a>), the following <code>errno</code> error
 conditions are defined for this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -34887,12 +34143,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="File%20Attributes">File Attributes</a>,
-Next:<a rel=next accesskey=n href="#Making%20Special%20Files">Making Special Files</a>,
-Previous:<a rel=previous accesskey=p href="#Creating%20Directories">Creating Directories</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="File Attributes">File Attributes</a>,
+Next:<a rel=next accesskey=n href="#Making Special Files">Making Special Files</a>,
+Previous:<a rel=previous accesskey=p href="#Creating Directories">Creating Directories</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>File Attributes</h3>
 
@@ -34904,60 +34160,59 @@
 <p>This section contains information about how you can inquire about and
 modify the attributes of a file.
 
 <ul>
-<li><a accesskey=1 href="#Attribute%20Meanings">Attribute Meanings</a>:           The names of the file attributes,
+<li><a accesskey=1 href="#Attribute Meanings">Attribute Meanings</a>:           The names of the file attributes,
                                  and what their values mean. 
-<li><a accesskey=2 href="#Reading%20Attributes">Reading Attributes</a>:           How to read the attributes of a file. 
-<li><a accesskey=3 href="#Testing%20File%20Type">Testing File Type</a>:            Distinguishing ordinary files,
+<li><a accesskey=2 href="#Reading Attributes">Reading Attributes</a>:           How to read the attributes of a file. 
+<li><a accesskey=3 href="#Testing File Type">Testing File Type</a>:            Distinguishing ordinary files,
                                  directories, links... 
-<li><a accesskey=4 href="#File%20Owner">File Owner</a>:                   How ownership for new files is determined,
+<li><a accesskey=4 href="#File Owner">File Owner</a>:                   How ownership for new files is determined,
 			         and how to change it. 
-<li><a accesskey=5 href="#Permission%20Bits">Permission Bits</a>:              How information about a file's access
+<li><a accesskey=5 href="#Permission Bits">Permission Bits</a>:              How information about a file's access
                                  mode is stored. 
-<li><a accesskey=6 href="#Access%20Permission">Access Permission</a>:            How the system decides who can access a file. 
-<li><a accesskey=7 href="#Setting%20Permissions">Setting Permissions</a>:          How permissions for new files are assigned,
+<li><a accesskey=6 href="#Access Permission">Access Permission</a>:            How the system decides who can access a file. 
+<li><a accesskey=7 href="#Setting Permissions">Setting Permissions</a>:          How permissions for new files are assigned,
 			         and how to change them. 
-<li><a accesskey=8 href="#Testing%20File%20Access">Testing File Access</a>:          How to find out if your process can
+<li><a accesskey=8 href="#Testing File Access">Testing File Access</a>:          How to find out if your process can
                                  access a file. 
-<li><a accesskey=9 href="#File%20Times">File Times</a>:                   About the time attributes of a file. 
-<li><a href="#File%20Size">File Size</a>: 			Manually changing the size of a file. 
+<li><a accesskey=9 href="#File Times">File Times</a>:                   About the time attributes of a file. 
+<li><a href="#File Size">File Size</a>: 			Manually changing the size of a file. 
 </ul>
 
 <p><hr>
-Node:<a name="Attribute%20Meanings">Attribute Meanings</a>,
-Next:<a rel=next accesskey=n href="#Reading%20Attributes">Reading Attributes</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="Attribute Meanings">Attribute Meanings</a>,
+Next:<a rel=next accesskey=n href="#Reading Attributes">Reading Attributes</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>The meaning of the File Attributes</h4>
 
 <p>When you read the attributes of a file, they come back in a structure
 called <code>struct stat</code>.  This section describes the names of the
 attributes, their data types, and what they mean.  For the functions
-to read the attributes of a file, see <a href="#Reading%20Attributes">Reading Attributes</a>.
+to read the attributes of a file, see <a href="#Reading Attributes">Reading Attributes</a>.
 
 <p>The header file <code>sys/stat.h</code> declares all the symbols defined
 in this section.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct stat</b><i>
-</i></td>
+<td align="left"><code><b>struct stat</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>stat</code> structure type is used to return information about the
 attributes of a file.  It contains at least the following members:
 
 <dl>
 <dt><code>mode_t st_mode</code>
 <dd>Specifies the mode of the file.  This includes file type information
-(see <a href="#Testing%20File%20Type">Testing File Type</a>) and the file permission bits
-(see <a href="#Permission%20Bits">Permission Bits</a>).
+(see <a href="#Testing File Type">Testing File Type</a>) and the file permission bits
+(see <a href="#Permission Bits">Permission Bits</a>).
 
 <br><dt><code>ino_t st_ino</code>
 <dd>The file serial number, which distinguishes this file from all other
 files on the same device.
@@ -34975,40 +34230,40 @@
 process still holds it open.  Symbolic links are not counted in the
 total.
 
 <br><dt><code>uid_t st_uid</code>
-<dd>The user ID of the file's owner.  See <a href="#File%20Owner">File Owner</a>.
+<dd>The user ID of the file's owner.  See <a href="#File Owner">File Owner</a>.
 
 <br><dt><code>gid_t st_gid</code>
-<dd>The group ID of the file.  See <a href="#File%20Owner">File Owner</a>.
+<dd>The group ID of the file.  See <a href="#File Owner">File Owner</a>.
 
 <br><dt><code>off_t st_size</code>
 <dd>This specifies the size of a regular file in bytes.  For files that are
 really devices this field isn't usually meaningful.  For symbolic links
 this specifies the length of the file name the link refers to.
 
 <br><dt><code>time_t st_atime</code>
-<dd>This is the last access time for the file.  See <a href="#File%20Times">File Times</a>.
+<dd>This is the last access time for the file.  See <a href="#File Times">File Times</a>.
 
 <br><dt><code>unsigned long int st_atime_usec</code>
 <dd>This is the fractional part of the last access time for the file. 
-See <a href="#File%20Times">File Times</a>.
+See <a href="#File Times">File Times</a>.
 
 <br><dt><code>time_t st_mtime</code>
 <dd>This is the time of the last modification to the contents of the file. 
-See <a href="#File%20Times">File Times</a>.
+See <a href="#File Times">File Times</a>.
 
 <br><dt><code>unsigned long int st_mtime_usec</code>
 <dd>This is the fractional part of the time of the last modification to the
-contents of the file.  See <a href="#File%20Times">File Times</a>.
+contents of the file.  See <a href="#File Times">File Times</a>.
 
 <br><dt><code>time_t st_ctime</code>
 <dd>This is the time of the last modification to the attributes of the file. 
-See <a href="#File%20Times">File Times</a>.
+See <a href="#File Times">File Times</a>.
 
 <br><dt><code>unsigned long int st_ctime_usec</code>
 <dd>This is the fractional part of the time of the last modification to the
-attributes of the file.  See <a href="#File%20Times">File Times</a>.
+attributes of the file.  See <a href="#File Times">File Times</a>.
 
 <br><dt><code>blkcnt_t st_blocks</code>
 <dd>This is the amount of disk space that the file occupies, measured in
 units of 512-byte blocks.
@@ -35041,16 +34296,15 @@
 machines, types which can handle file sizes up to 2^63. 
 Therefore a new definition of <code>struct stat</code> is necessary.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct stat64</b><i>
-</i></td>
+<td align="left"><code><b>struct stat64</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The members of this type are the same and have the same names as those
 in <code>struct stat</code>.  The only difference is that the members
 <code>st_ino</code>, <code>st_size</code>, and <code>st_blocks</code> have a different
@@ -35058,10 +34312,10 @@
 
 <dl>
 <dt><code>mode_t st_mode</code>
 <dd>Specifies the mode of the file.  This includes file type information
-(see <a href="#Testing%20File%20Type">Testing File Type</a>) and the file permission bits
-(see <a href="#Permission%20Bits">Permission Bits</a>).
+(see <a href="#Testing File Type">Testing File Type</a>) and the file permission bits
+(see <a href="#Permission Bits">Permission Bits</a>).
 
 <br><dt><code>ino64_t st_ino</code>
 <dd>The file serial number, which distinguishes this file from all other
 files on the same device.
@@ -35079,40 +34333,40 @@
 process still holds it open.  Symbolic links are not counted in the
 total.
 
 <br><dt><code>uid_t st_uid</code>
-<dd>The user ID of the file's owner.  See <a href="#File%20Owner">File Owner</a>.
+<dd>The user ID of the file's owner.  See <a href="#File Owner">File Owner</a>.
 
 <br><dt><code>gid_t st_gid</code>
-<dd>The group ID of the file.  See <a href="#File%20Owner">File Owner</a>.
+<dd>The group ID of the file.  See <a href="#File Owner">File Owner</a>.
 
 <br><dt><code>off64_t st_size</code>
 <dd>This specifies the size of a regular file in bytes.  For files that are
 really devices this field isn't usually meaningful.  For symbolic links
 this specifies the length of the file name the link refers to.
 
 <br><dt><code>time_t st_atime</code>
-<dd>This is the last access time for the file.  See <a href="#File%20Times">File Times</a>.
+<dd>This is the last access time for the file.  See <a href="#File Times">File Times</a>.
 
 <br><dt><code>unsigned long int st_atime_usec</code>
 <dd>This is the fractional part of the last access time for the file. 
-See <a href="#File%20Times">File Times</a>.
+See <a href="#File Times">File Times</a>.
 
 <br><dt><code>time_t st_mtime</code>
 <dd>This is the time of the last modification to the contents of the file. 
-See <a href="#File%20Times">File Times</a>.
+See <a href="#File Times">File Times</a>.
 
 <br><dt><code>unsigned long int st_mtime_usec</code>
 <dd>This is the fractional part of the time of the last modification to the
-contents of the file.  See <a href="#File%20Times">File Times</a>.
+contents of the file.  See <a href="#File Times">File Times</a>.
 
 <br><dt><code>time_t st_ctime</code>
 <dd>This is the time of the last modification to the attributes of the file. 
-See <a href="#File%20Times">File Times</a>.
+See <a href="#File Times">File Times</a>.
 
 <br><dt><code>unsigned long int st_ctime_usec</code>
 <dd>This is the fractional part of the time of the last modification to the
-attributes of the file.  See <a href="#File%20Times">File Times</a>.
+attributes of the file.  See <a href="#File Times">File Times</a>.
 
 <br><dt><code>blkcnt64_t st_blocks</code>
 <dd>This is the amount of disk space that the file occupies, measured in
 units of 512-byte blocks.
@@ -35131,31 +34385,29 @@
 in the header file <code>sys/types.h</code> as well as in <code>sys/stat.h</code>. 
 Here is a list of them.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>mode_t</b><i>
-</i></td>
+<td align="left"><code><b>mode_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an integer data type used to represent file modes.  In the
 GNU system, this is equivalent to <code>unsigned int</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>ino_t</b><i>
-</i></td>
+<td align="left"><code><b>ino_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an arithmetic data type used to represent file serial numbers. 
 (In Unix jargon, these are sometimes called <dfn>inode numbers</dfn>.) 
 In the GNU system, this type is equivalent to <code>unsigned long int</code>.
@@ -35165,16 +34417,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>ino64_t</b><i>
-</i></td>
+<td align="left"><code><b>ino64_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an arithmetic data type used to represent file serial numbers
 for the use in LFS.  In the GNU system, this type is equivalent to
 <code>unsigned long longint</code>.
@@ -35184,46 +34435,43 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>dev_t</b><i>
-</i></td>
+<td align="left"><code><b>dev_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an arithmetic data type used to represent file device numbers. 
 In the GNU system, this is equivalent to <code>int</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>nlink_t</b><i>
-</i></td>
+<td align="left"><code><b>nlink_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an arithmetic data type used to represent file link counts. 
 In the GNU system, this is equivalent to <code>unsigned short int</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>blkcnt_t</b><i>
-</i></td>
+<td align="left"><code><b>blkcnt_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an arithmetic data type used to represent block counts. 
 In the GNU system, this is equivalent to <code>unsigned long int</code>.
 
@@ -35232,16 +34480,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>blkcnt64_t</b><i>
-</i></td>
+<td align="left"><code><b>blkcnt64_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an arithmetic data type used to represent block counts for the
 use in LFS.  In the GNU system, this is equivalent to <code>unsigned
 long long int</code>.
@@ -35251,12 +34498,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Reading%20Attributes">Reading Attributes</a>,
-Next:<a rel=next accesskey=n href="#Testing%20File%20Type">Testing File Type</a>,
-Previous:<a rel=previous accesskey=p href="#Attribute%20Meanings">Attribute Meanings</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="Reading Attributes">Reading Attributes</a>,
+Next:<a rel=next accesskey=n href="#Testing File Type">Testing File Type</a>,
+Previous:<a rel=previous accesskey=p href="#Attribute Meanings">Attribute Meanings</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>Reading the Attributes of a File</h4>
 
@@ -35265,16 +34512,15 @@
 a <code>struct stat</code> object.  All three functions are declared in the
 header file <code>sys/stat.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>stat</b><i> (const char *<var>filename</var>, struct stat *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>stat</b><i> (const char *<var>filename</var>, struct stat *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>stat</code> function returns information about the attributes of the
 file named by <var>filename</var> in the structure pointed to by <var>buf</var>.
 
@@ -35284,9 +34530,9 @@
 file.
 
 <p>The return value is <code>0</code> if the operation is successful, or
 <code>-1</code> on failure.  In addition to the usual file name errors
-(see <a href="#File%20Name%20Errors">File Name Errors</a>, the following <code>errno</code> error conditions
+(see <a href="#File Name Errors">File Name Errors</a>, the following <code>errno</code> error conditions
 are defined for this function:
 
 <dl>
 <dt><code>ENOENT</code>
@@ -35299,16 +34545,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>stat64</b><i> (const char *<var>filename</var>, struct stat64 *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>stat64</b><i> (const char *<var>filename</var>, struct stat64 *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>stat</code> but it is also able to work on
 files larger then 2^31 bytes on 32-bit systems.  To be able to do
 this the result is stored in a variable of type <code>struct stat64</code> to
@@ -35320,20 +34565,19 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fstat</b><i> (int <var>filedes</var>, struct stat *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>fstat</b><i> (int <var>filedes</var>, struct stat *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fstat</code> function is like <code>stat</code>, except that it takes an
 open file descriptor as an argument instead of a file name. 
-See <a href="#Low-Level%20I%2fO">Low-Level I/O</a>.
+See <a href="#Low-Level I%2fO">Low-Level I/O</a>.
 
 <p>Like <code>stat</code>, <code>fstat</code> returns <code>0</code> on success and <code>-1</code>
 on failure.  The following <code>errno</code> error conditions are defined for
 <code>fstat</code>:
@@ -35349,16 +34593,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fstat64</b><i> (int <var>filedes</var>, struct stat64 *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>fstat64</b><i> (int <var>filedes</var>, struct stat64 *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fstat</code> but is able to work on large
 files on 32-bit platforms.  For large files the file descriptor
 <var>filedes</var> should be obtained by <code>open64</code> or <code>creat64</code>. 
@@ -35371,37 +34614,35 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>lstat</b><i> (const char *<var>filename</var>, struct stat *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>lstat</b><i> (const char *<var>filename</var>, struct stat *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lstat</code> function is like <code>stat</code>, except that it does not
 follow symbolic links.  If <var>filename</var> is the name of a symbolic
 link, <code>lstat</code> returns information about the link itself; otherwise
-<code>lstat</code> works like <code>stat</code>.  See <a href="#Symbolic%20Links">Symbolic Links</a>.
+<code>lstat</code> works like <code>stat</code>.  See <a href="#Symbolic Links">Symbolic Links</a>.
 
 <p>When the sources are compiled with <code>_FILE_OFFSET_BITS == 64</code> this
 function is in fact <code>lstat64</code> since the LFS interface transparently
 replaces the normal implementation. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>lstat64</b><i> (const char *<var>filename</var>, struct stat64 *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>lstat64</b><i> (const char *<var>filename</var>, struct stat64 *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>lstat</code> but it is also able to work on
 files larger then 2^31 bytes on 32-bit systems.  To be able to do
 this the result is stored in a variable of type <code>struct stat64</code> to
@@ -35413,12 +34654,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Testing%20File%20Type">Testing File Type</a>,
-Next:<a rel=next accesskey=n href="#File%20Owner">File Owner</a>,
-Previous:<a rel=previous accesskey=p href="#Reading%20Attributes">Reading Attributes</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="Testing File Type">Testing File Type</a>,
+Next:<a rel=next accesskey=n href="#File Owner">File Owner</a>,
+Previous:<a rel=previous accesskey=p href="#Reading Attributes">Reading Attributes</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>Testing the Type of a File</h4>
 
@@ -35426,9 +34667,9 @@
 attributes, contains two kinds of information: the file type code, and
 the access permission bits.  This section discusses only the type code,
 which you can use to tell whether the file is a directory, socket,
 symbolic link, and so on.  For details about access permissions see
-<a href="#Permission%20Bits">Permission Bits</a>.
+<a href="#Permission Bits">Permission Bits</a>.
 
 <p>There are two ways you can access the file type information in a file
 mode.  Firstly, for each file type there is a <dfn>predicate macro</dfn>
 which examines a given file mode and returns whether it is of that type
@@ -35443,104 +34684,97 @@
 <var>m</var> which is the <code>st_mode</code> field returned by <code>stat</code> on
 that file:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_ISDIR</b><i> (mode_t <var>m</var>)
-</i></td>
+<td align="left"><code>int <b>S_ISDIR</b><i> (mode_t <var>m</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns non-zero if the file is a directory. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_ISCHR</b><i> (mode_t <var>m</var>)
-</i></td>
+<td align="left"><code>int <b>S_ISCHR</b><i> (mode_t <var>m</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns non-zero if the file is a character special file (a
 device like a terminal). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_ISBLK</b><i> (mode_t <var>m</var>)
-</i></td>
+<td align="left"><code>int <b>S_ISBLK</b><i> (mode_t <var>m</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns non-zero if the file is a block special file (a device
 like a disk). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_ISREG</b><i> (mode_t <var>m</var>)
-</i></td>
+<td align="left"><code>int <b>S_ISREG</b><i> (mode_t <var>m</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns non-zero if the file is a regular file. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_ISFIFO</b><i> (mode_t <var>m</var>)
-</i></td>
+<td align="left"><code>int <b>S_ISFIFO</b><i> (mode_t <var>m</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns non-zero if the file is a FIFO special file, or a
-pipe.  See <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>. 
+pipe.  See <a href="#Pipes and FIFOs">Pipes and FIFOs</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_ISLNK</b><i> (mode_t <var>m</var>)
-</i></td>
+<td align="left"><code>int <b>S_ISLNK</b><i> (mode_t <var>m</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns non-zero if the file is a symbolic link. 
-See <a href="#Symbolic%20Links">Symbolic Links</a>. 
+See <a href="#Symbolic Links">Symbolic Links</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_ISSOCK</b><i> (mode_t <var>m</var>)
-</i></td>
+<td align="left"><code>int <b>S_ISSOCK</b><i> (mode_t <var>m</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns non-zero if the file is a socket.  See <a href="#Sockets">Sockets</a>. 
 </td></tr>
 </table>
@@ -35558,16 +34792,15 @@
 <br><pre>((<var>mode</var> &amp; S_IFMT) == S_IFCHR)
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_IFMT</b><i>
-</i></td>
+<td align="left"><code>int <b>S_IFMT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a bit mask used to extract the file type code from a mode value. 
 </td></tr>
 </table>
@@ -35605,60 +34838,57 @@
 <code>st_mode</code> field as the parameter.  Instead they expect a pointer to
 the whole <code>struct stat</code> structure.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_TYPEISMQ</b><i> (struct stat *<var>s</var>)
-</i></td>
+<td align="left"><code>int <b>S_TYPEISMQ</b><i> (struct stat *<var>s</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the system implement POSIX message queues as distinct objects and the
 file is a message queue object, this macro returns a non-zero value. 
 In all other cases the result is zero. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_TYPEISSEM</b><i> (struct stat *<var>s</var>)
-</i></td>
+<td align="left"><code>int <b>S_TYPEISSEM</b><i> (struct stat *<var>s</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the system implement POSIX semaphores as distinct objects and the
 file is a semaphore object, this macro returns a non-zero value. 
 In all other cases the result is zero. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>S_TYPEISSHM</b><i> (struct stat *<var>s</var>)
-</i></td>
+<td align="left"><code>int <b>S_TYPEISSHM</b><i> (struct stat *<var>s</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the system implement POSIX shared memory objects as distinct objects
 and the file is an shared memory object, this macro returns a non-zero
 value.  In all other cases the result is zero. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="File%20Owner">File Owner</a>,
-Next:<a rel=next accesskey=n href="#Permission%20Bits">Permission Bits</a>,
-Previous:<a rel=previous accesskey=p href="#Testing%20File%20Type">Testing File Type</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="File Owner">File Owner</a>,
+Next:<a rel=next accesskey=n href="#Permission Bits">Permission Bits</a>,
+Previous:<a rel=previous accesskey=p href="#Testing File Type">Testing File Type</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>File Owner</h4>
 
@@ -35670,13 +34900,13 @@
 
 <p>The file owner and group play a role in determining access because the
 file has one set of access permission bits for the owner, another set
 that applies to users who belong to the file's group, and a third set of
-bits that applies to everyone else.  See <a href="#Access%20Permission">Access Permission</a>, for the
+bits that applies to everyone else.  See <a href="#Access Permission">Access Permission</a>, for the
 details of how access is decided based on this data.
 
 <p>When a file is created, its owner is set to the effective user ID of the
-process that creates it (see <a href="#Process%20Persona">Process Persona</a>).  The file's group ID
+process that creates it (see <a href="#Process Persona">Process Persona</a>).  The file's group ID
 may be set to either the effective group ID of the process, or the group
 ID of the directory that contains the file, depending on the system
 where the file is stored.  When you access a remote file system, it
 behaves according to its own rules, not according to the system your
@@ -35689,16 +34919,15 @@
 
 <p>The prototype for this function is declared in <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>chown</b><i> (const char *<var>filename</var>, uid_t <var>owner</var>, gid_t <var>group</var>)
-</i></td>
+<td align="left"><code>int <b>chown</b><i> (const char *<var>filename</var>, uid_t <var>owner</var>, gid_t <var>group</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>chown</code> function changes the owner of the file <var>filename</var> to
 <var>owner</var>, and its group owner to <var>group</var>.
 
@@ -35707,9 +34936,9 @@
 be appropriate for the new owner.)  Other file permission bits are not
 changed.
 
 <p>The return value is <code>0</code> on success and <code>-1</code> on failure. 
-In addition to the usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>),
+In addition to the usual file name errors (see <a href="#File Name Errors">File Name Errors</a>),
 the following <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EPERM</code>
@@ -35721,9 +34950,9 @@
 owner.  When you access a remote file system, the behavior you encounter
 is determined by the system that actually holds the file, not by the
 system your program is running on.
 
-<p>See <a href="#Options%20for%20Files">Options for Files</a>, for information about the
+<p>See <a href="#Options for Files">Options for Files</a>, for information about the
 <code>_POSIX_CHOWN_RESTRICTED</code> macro.
 
 <br><dt><code>EROFS</code>
 <dd>The file is on a read-only file system. 
@@ -35731,16 +34960,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fchown</b><i> (int <var>filedes</var>, int <var>owner</var>, int <var>group</var>)
-</i></td>
+<td align="left"><code>int <b>fchown</b><i> (int <var>filedes</var>, int <var>owner</var>, int <var>group</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>chown</code>, except that it changes the owner of the open
 file with descriptor <var>filedes</var>.
 
@@ -35766,21 +34994,21 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Permission%20Bits">Permission Bits</a>,
-Next:<a rel=next accesskey=n href="#Access%20Permission">Access Permission</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Owner">File Owner</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="Permission Bits">Permission Bits</a>,
+Next:<a rel=next accesskey=n href="#Access Permission">Access Permission</a>,
+Previous:<a rel=previous accesskey=p href="#File Owner">File Owner</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>The Mode Bits for Access Permission</h4>
 
 <p>The <dfn>file mode</dfn>, stored in the <code>st_mode</code> field of the file
 attributes, contains two kinds of information: the file type code, and
 the access permission bits.  This section discusses only the access
 permission bits, which control who can read or write the file. 
-See <a href="#Testing%20File%20Type">Testing File Type</a>, for information about the file type code.
+See <a href="#Testing File Type">Testing File Type</a>, for information about the file type code.
 
 <p>All of the symbols listed in this section are defined in the header file
 <code>sys/stat.h</code>.
 
@@ -35834,13 +35062,13 @@
 <dd>This is equivalent to <code>(S_IROTH | S_IWOTH | S_IXOTH)</code>.
 
 <br><dt><code>S_ISUID</code>
 <dd>This is the set-user-ID on execute bit, usually 04000. 
-See <a href="#How%20Change%20Persona">How Change Persona</a>.
+See <a href="#How Change Persona">How Change Persona</a>.
 
 <br><dt><code>S_ISGID</code>
 <dd>This is the set-group-ID on execute bit, usually 02000. 
-See <a href="#How%20Change%20Persona">How Change Persona</a>.
+See <a href="#How Change Persona">How Change Persona</a>.
 
 <br><dt><code>S_ISVTX</code>
 <dd>This is the <dfn>sticky</dfn> bit, usually 01000.
 
@@ -35868,9 +35096,9 @@
 
 <p>On some modern systems where the sticky bit has no useful meaning for an
 executable file, you cannot set the bit at all for a non-directory. 
 If you try, <code>chmod</code> fails with <code>EFTYPE</code>;
-see <a href="#Setting%20Permissions">Setting Permissions</a>.
+see <a href="#Setting Permissions">Setting Permissions</a>.
 
 <p>Some systems (particularly SunOS) have yet another use for the sticky
 bit.  If the sticky bit is set on a file that is <em>not</em> executable,
 it means the opposite: never cache the pages of this file at all.  The
@@ -35883,9 +35111,9 @@
 no-one cares for a swap file).
 
 <p>This bit is only available on BSD systems (and those derived from
 them).  Therefore one has to use the <code>_BSD_SOURCE</code> feature select
-macro to get the definition (see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>). 
+macro to get the definition (see <a href="#Feature Test Macros">Feature Test Macros</a>). 
 </dl>
 
 <p>The actual bit values of the symbols are listed in the table above
 so you can decode file mode values when debugging your programs. 
@@ -35897,20 +35125,20 @@
 reads your program to remember what the bits mean.  To make your program
 clean use the symbolic names.
 
 <p><hr>
-Node:<a name="Access%20Permission">Access Permission</a>,
-Next:<a rel=next accesskey=n href="#Setting%20Permissions">Setting Permissions</a>,
-Previous:<a rel=previous accesskey=p href="#Permission%20Bits">Permission Bits</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="Access Permission">Access Permission</a>,
+Next:<a rel=next accesskey=n href="#Setting Permissions">Setting Permissions</a>,
+Previous:<a rel=previous accesskey=p href="#Permission Bits">Permission Bits</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>How Your Access to a File is Decided</h4>
 
 <p>Recall that the operating system normally decides access permission for
 a file based on the effective user and group IDs of the process and its
 supplementary group IDs, together with the file's owner, group and
-permission bits.  These concepts are discussed in detail in <a href="#Process%20Persona">Process Persona</a>.
+permission bits.  These concepts are discussed in detail in <a href="#Process Persona">Process Persona</a>.
 
 <p>If the effective user ID of the process matches the owner user ID of the
 file, then permissions for read, write, and execute/search are
 controlled by the corresponding "user" (or "owner") bits.  Likewise,
@@ -35923,12 +35151,12 @@
 its permission bits.  As a special case, for a file to be executable
 even by a privileged user, at least one of its execute bits must be set.
 
 <p><hr>
-Node:<a name="Setting%20Permissions">Setting Permissions</a>,
-Next:<a rel=next accesskey=n href="#Testing%20File%20Access">Testing File Access</a>,
-Previous:<a rel=previous accesskey=p href="#Access%20Permission">Access Permission</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="Setting Permissions">Setting Permissions</a>,
+Next:<a rel=next accesskey=n href="#Testing File Access">Testing File Access</a>,
+Previous:<a rel=previous accesskey=p href="#Access Permission">Access Permission</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>Assigning File Permissions</h4>
 
@@ -35970,16 +35198,15 @@
 
 <p>The functions in this section are declared in <code>sys/stat.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">mode_t <b>umask</b><i> (mode_t <var>mask</var>)
-</i></td>
+<td align="left"><code>mode_t <b>umask</b><i> (mode_t <var>mask</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>umask</code> function sets the file creation mask of the current
 process to <var>mask</var>, and returns the previous value of the file
 creation mask.
@@ -36002,31 +35229,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">mode_t <b>getumask</b><i> (void)
-</i></td>
+<td align="left"><code>mode_t <b>getumask</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Return the current value of the file creation mask for the current
 process.  This function is a GNU extension. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>chmod</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>chmod</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>chmod</code> function sets the access permission bits for the file
 named by <var>filename</var> to <var>mode</var>.
 
@@ -36034,9 +35259,9 @@
 permissions of the file pointed to by the link, not those of the link
 itself.
 
 <p>This function returns <code>0</code> if successful and <code>-1</code> if not.  In
-addition to the usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following <code>errno</code> error conditions are defined for
+addition to the usual file name errors (see <a href="#File Name Errors">File Name Errors</a>), the following <code>errno</code> error conditions are defined for
 this function:
 
 <dl>
 <dt><code>ENOENT</code>
@@ -36057,23 +35282,22 @@
 assign a useful meaning to the bit for non-directory files).
 
 <p>You only get <code>EFTYPE</code> on systems where the sticky bit has no useful
 meaning for non-directory files, so it is always safe to just clear the
-bit in <var>mode</var> and call <code>chmod</code> again.  See <a href="#Permission%20Bits">Permission Bits</a>,
+bit in <var>mode</var> and call <code>chmod</code> again.  See <a href="#Permission Bits">Permission Bits</a>,
 for full details on the sticky bit. 
 </dl>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fchmod</b><i> (int <var>filedes</var>, int <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>fchmod</b><i> (int <var>filedes</var>, int <var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is like <code>chmod</code>, except that it changes the permissions of the
 currently open file given by <var>filedes</var>.
 
@@ -36100,12 +35324,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Testing%20File%20Access">Testing File Access</a>,
-Next:<a rel=next accesskey=n href="#File%20Times">File Times</a>,
-Previous:<a rel=previous accesskey=p href="#Setting%20Permissions">Setting Permissions</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="Testing File Access">Testing File Access</a>,
+Next:<a rel=next accesskey=n href="#File Times">File Times</a>,
+Previous:<a rel=previous accesskey=p href="#Setting Permissions">Setting Permissions</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>Testing Permission to Access a File</h4>
 
@@ -36144,16 +35368,15 @@
 
 <p>The symbols in this section are declared in <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>access</b><i> (const char *<var>filename</var>, int <var>how</var>)
-</i></td>
+<td align="left"><code>int <b>access</b><i> (const char *<var>filename</var>, int <var>how</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>access</code> function checks to see whether the file named by
 <var>filename</var> can be accessed in the way specified by the <var>how</var>
 argument.  The <var>how</var> argument either can be the bitwise OR of the
@@ -36162,16 +35385,16 @@
 
 <p>This function uses the <em>real</em> user and group IDs of the calling
 process, rather than the <em>effective</em> IDs, to check for access
 permission.  As a result, if you use the function from a <code>setuid</code>
-or <code>setgid</code> program (see <a href="#How%20Change%20Persona">How Change Persona</a>), it gives
+or <code>setgid</code> program (see <a href="#How Change Persona">How Change Persona</a>), it gives
 information relative to the user who actually ran the program.
 
 <p>The return value is <code>0</code> if the access is permitted, and <code>-1</code>
 otherwise.  (In other words, treated as a predicate function,
 <code>access</code> returns true if the requested access is <em>denied</em>.)
 
-<p>In addition to the usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following <code>errno</code> error conditions are defined for
+<p>In addition to the usual file name errors (see <a href="#File Name Errors">File Name Errors</a>), the following <code>errno</code> error conditions are defined for
 this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -36190,81 +35413,77 @@
 as the <var>how</var> argument to the <code>access</code> function.  The values
 are integer constants.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>R_OK</b><i>
-</i></td>
+<td align="left"><code>int <b>R_OK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Flag meaning test for read permission. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>W_OK</b><i>
-</i></td>
+<td align="left"><code>int <b>W_OK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Flag meaning test for write permission. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>X_OK</b><i>
-</i></td>
+<td align="left"><code>int <b>X_OK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Flag meaning test for execute/search permission. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>F_OK</b><i>
-</i></td>
+<td align="left"><code>int <b>F_OK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Flag meaning test for existence of the file. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="File%20Times">File Times</a>,
-Next:<a rel=next accesskey=n href="#File%20Size">File Size</a>,
-Previous:<a rel=previous accesskey=p href="#Testing%20File%20Access">Testing File Access</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="File Times">File Times</a>,
+Next:<a rel=next accesskey=n href="#File Size">File Size</a>,
+Previous:<a rel=previous accesskey=p href="#Testing File Access">Testing File Access</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>File Times</h4>
 
 <p>Each file has three time stamps associated with it:  its access time,
 its modification time, and its attribute modification time.  These
 correspond to the <code>st_atime</code>, <code>st_mtime</code>, and <code>st_ctime</code>
-members of the <code>stat</code> structure; see <a href="#File%20Attributes">File Attributes</a>.
+members of the <code>stat</code> structure; see <a href="#File Attributes">File Attributes</a>.
 
 <p>All of these times are represented in calendar time format, as
 <code>time_t</code> objects.  This data type is defined in <code>time.h</code>. 
 For more information about representation and manipulation of time
-values, see <a href="#Calendar%20Time">Calendar Time</a>.
+values, see <a href="#Calendar Time">Calendar Time</a>.
 
 <p>Reading from a file updates its access time attribute, and writing
 updates its modification time.  When a file is created, all three
 time stamps for that file are set to the current time.  In addition, the
@@ -36287,16 +35506,15 @@
 the <code>utime</code> function--all except the attribute change time.  You
 need to include the header file <code>utime.h</code> to use this facility.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct utimbuf</b><i>
-</i></td>
+<td align="left"><code><b>struct utimbuf</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>utimbuf</code> structure is used with the <code>utime</code> function to
 specify new access and modification times for a file.  It contains the
 following members:
@@ -36311,16 +35529,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>utime</b><i> (const char *<var>filename</var>, const struct utimbuf *<var>times</var>)
-</i></td>
+<td align="left"><code>int <b>utime</b><i> (const char *<var>filename</var>, const struct utimbuf *<var>times</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to modify the file times associated with the file
 named <var>filename</var>.
 
@@ -36334,9 +35551,9 @@
 of the file attributes).
 
 <p>The <code>utime</code> function returns <code>0</code> if successful and <code>-1</code>
 on failure.  In addition to the usual file name errors
-(see <a href="#File%20Name%20Errors">File Name Errors</a>), the following <code>errno</code> error conditions
+(see <a href="#File Name Errors">File Name Errors</a>), the following <code>errno</code> error conditions
 are defined for this function:
 
 <dl>
 <dt><code>EACCES</code>
@@ -36362,23 +35579,22 @@
 which extends its resolution.  These fields are called
 <code>st_atime_usec</code>, <code>st_mtime_usec</code>, and <code>st_ctime_usec</code>;
 each has a value between 0 and 999,999, which indicates the time in
 microseconds.  They correspond to the <code>tv_usec</code> field of a
-<code>timeval</code> structure; see <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.
+<code>timeval</code> structure; see <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.
 
 <p>The <code>utimes</code> function is like <code>utime</code>, but also lets you specify
 the fractional part of the file times.  The prototype for this function is
 in the header file <code>sys/time.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>utimes</b><i> (const char *<var>filename</var>, struct timeval <var>tvp</var><tt>[2]</tt>)
-</i></td>
+<td align="left"><code>int <b>utimes</b><i> (const char *<var>filename</var>, struct timeval <var>tvp</var><tt>[2]</tt>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the file access and modification times of the file
 <var>filename</var>.  The new file access time is specified by
 <code><var>tvp</var>[0]</code>, and the new modification time by
@@ -36389,11 +35605,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="File%20Size">File Size</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Times">File Times</a>,
-Up:<a rel=up accesskey=u href="#File%20Attributes">File Attributes</a>
+Node:<a name="File Size">File Size</a>,
+Previous:<a rel=previous accesskey=p href="#File Times">File Times</a>,
+Up:<a rel=up accesskey=u href="#File Attributes">File Attributes</a>
 <br>
 
 <h4>File Size</h4>
 
@@ -36408,25 +35624,24 @@
 POSIX.1.
 
 <p>Some systems allow you to extend a file (creating holes) with these
 functions.  This is useful when using memory-mapped I/O
-(see <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>), where files are not automatically extended. 
+(see <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>), where files are not automatically extended. 
 However, it is not portable but must be implemented if <code>mmap</code>
 allows mapping of files (i.e., <code>_POSIX_MAPPED_FILES</code> is defined).
 
 <p>Using these functions on anything other than a regular file gives
 <em>undefined</em> results.  On many systems, such a call will appear to
 succeed, without actually accomplishing anything.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>truncate</b><i> (const char *<var>filename</var>, off_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>truncate</b><i> (const char *<var>filename</var>, off_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>truncate</code> function changes the size of <var>filename</var> to
 <var>length</var>.  If <var>length</var> is shorter than the previous length, data
@@ -36469,16 +35684,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>truncate64</b><i> (const char *<var>name</var>, off64_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>truncate64</b><i> (const char *<var>name</var>, off64_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>truncate</code> function.  The
 difference is that the <var>length</var> argument is 64 bits wide even on 32
 bits machines, which allows the handling of files with sizes up to
@@ -36490,16 +35704,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ftruncate</b><i> (int <var>fd</var>, off_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>ftruncate</b><i> (int <var>fd</var>, off_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This is like <code>truncate</code>, but it works on a file descriptor <var>fd</var>
 for an opened file instead of a file name to identify the object.  The
@@ -36556,16 +35769,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ftruncate64</b><i> (int <var>id</var>, off64_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>ftruncate64</b><i> (int <var>id</var>, off64_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>ftruncate</code> function.  The
 difference is that the <var>length</var> argument is 64 bits wide even on 32
 bits machines which allows the handling of files with sizes up to
@@ -36613,12 +35825,12 @@
 real size, and when it has finished a final <code>ftruncate</code> call should
 set the real size of the file.
 
 <p><hr>
-Node:<a name="Making%20Special%20Files">Making Special Files</a>,
-Next:<a rel=next accesskey=n href="#Temporary%20Files">Temporary Files</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Attributes">File Attributes</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Making Special Files">Making Special Files</a>,
+Next:<a rel=next accesskey=n href="#Temporary Files">Temporary Files</a>,
+Previous:<a rel=previous accesskey=p href="#File Attributes">File Attributes</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Making Special Files</h3>
 
@@ -36628,27 +35840,26 @@
 
 <p>The prototype for <code>mknod</code> is declared in <code>sys/stat.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mknod</b><i> (const char *<var>filename</var>, int <var>mode</var>, int <var>dev</var>)
-</i></td>
+<td align="left"><code>int <b>mknod</b><i> (const char *<var>filename</var>, int <var>mode</var>, int <var>dev</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mknod</code> function makes a special file with name <var>filename</var>. 
 The <var>mode</var> specifies the mode of the file, and may include the various
 special file bits, such as <code>S_IFCHR</code> (for a character special file)
-or <code>S_IFBLK</code> (for a block special file).  See <a href="#Testing%20File%20Type">Testing File Type</a>.
+or <code>S_IFBLK</code> (for a block special file).  See <a href="#Testing File Type">Testing File Type</a>.
 
 <p>The <var>dev</var> argument specifies which device the special file refers to. 
 Its exact interpretation depends on the kind of special file being created.
 
 <p>The return value is <code>0</code> on success and <code>-1</code> on error.  In addition
-to the usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the
+to the usual file name errors (see <a href="#File Name Errors">File Name Errors</a>), the
 following <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EPERM</code>
@@ -36670,11 +35881,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Temporary%20Files">Temporary Files</a>,
-Previous:<a rel=previous accesskey=p href="#Making%20Special%20Files">Making Special Files</a>,
-Up:<a rel=up accesskey=u href="#File%20System%20Interface">File System Interface</a>
+Node:<a name="Temporary Files">Temporary Files</a>,
+Previous:<a rel=previous accesskey=p href="#Making Special Files">Making Special Files</a>,
+Up:<a rel=up accesskey=u href="#File System Interface">File System Interface</a>
 <br>
 
 <h3>Temporary Files</h3>
 
@@ -36691,16 +35902,15 @@
 
 <p>These facilities are declared in the header file <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>tmpfile</b><i> (void)
-</i></td>
+<td align="left"><code>FILE * <b>tmpfile</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function creates a temporary binary file for update mode, as if by
 calling <code>fopen</code> with mode <code>"wb+"</code>.  The file is deleted
 automatically when it is closed or when the program terminates.  (On
@@ -36715,16 +35925,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>tmpfile64</b><i> (void)
-</i></td>
+<td align="left"><code>FILE * <b>tmpfile64</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>tmpfile</code>, but the stream it returns a
 pointer to was opened using <code>tmpfile64</code>.  Therefore this stream can
 be used for files larger then 2^31 bytes on 32-bit machines.
@@ -36738,16 +35947,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>tmpnam</b><i> (char *<var>result</var>)
-</i></td>
+<td align="left"><code>char * <b>tmpnam</b><i> (char *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function constructs and returns a valid file name that does not
 refer to any existing file.  If the <var>result</var> argument is a null
 pointer, the return value is a pointer to an internal static string,
@@ -36770,16 +35978,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>tmpnam_r</b><i> (char *<var>result</var>)
-</i></td>
+<td align="left"><code>char * <b>tmpnam_r</b><i> (char *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is nearly identical to the <code>tmpnam</code> function, except
 that if <var>result</var> is a null pointer it returns a null pointer.
 
@@ -36791,32 +35998,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>L_tmpnam</b><i>
-</i></td>
+<td align="left"><code>int <b>L_tmpnam</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that
 represents the minimum size of a string large enough to hold a file name
 generated by the <code>tmpnam</code> function. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>TMP_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>TMP_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The macro <code>TMP_MAX</code> is a lower bound for how many temporary names
 you can create with <code>tmpnam</code>.  You can rely on being able to call
 <code>tmpnam</code> at least this many times before it might fail saying you
@@ -36830,16 +36035,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>tempnam</b><i> (const char *<var>dir</var>, const char *<var>prefix</var>)
-</i></td>
+<td align="left"><code>char * <b>tempnam</b><i> (const char *<var>dir</var>, const char *<var>prefix</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function generates a unique temporary file name.  If <var>prefix</var>
 is not a null pointer, up to five characters of this string are used as
 a prefix for the file name.  The return value is a string newly
@@ -36874,16 +36078,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>P_tmpdir</b><i>
-</i></td>
+<td align="left"><code>char * <b>P_tmpdir</b><i></i></code></td>
 <td align="right">SVID Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is the name of the default directory for temporary files. 
 </td></tr>
 </table>
@@ -36902,16 +36105,15 @@
 would crash when <code>mktemp</code> or <code>mkstemp</code> tried to modify the
 string.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>mktemp</b><i> (char *<var>template</var>)
-</i></td>
+<td align="left"><code>char * <b>mktemp</b><i> (char *<var>template</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mktemp</code> function generates a unique file name by modifying
 <var>template</var> as described above.  If successful, it returns
 <var>template</var> as modified.  If <code>mktemp</code> cannot find a unique file
@@ -36928,20 +36130,19 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mkstemp</b><i> (char *<var>template</var>)
-</i></td>
+<td align="left"><code>int <b>mkstemp</b><i> (char *<var>template</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mkstemp</code> function generates a unique file name just as
 <code>mktemp</code> does, but it also opens the file for you with <code>open</code>
-(see <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>).  If successful, it modifies
+(see <a href="#Opening and Closing Files">Opening and Closing Files</a>).  If successful, it modifies
 <var>template</var> in place and returns a file descriptor for that file open
 for reading and writing.  If <code>mkstemp</code> cannot create a
 uniquely-named file, it returns <code>-1</code>.  If <var>template</var> does not
 end with <code>XXXXXX</code>, <code>mkstemp</code> returns <code>-1</code> and does not
@@ -36958,16 +36159,15 @@
 <code>open</code> with the <code>O_EXCL</code> flag, which says you want to create a
 new file and get an error if the file already exists.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>mkdtemp</b><i> (char *<var>template</var>)
-</i></td>
+<td align="left"><code>char * <b>mkdtemp</b><i> (char *<var>template</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mkdtemp</code> function creates a directory with a unique name.  If
 it succeeds, it overwrites <var>template</var> with the name of the
 directory, and returns <var>template</var>.  As with <code>mktemp</code> and
@@ -36986,16 +36186,16 @@
 
 <p>The directory created by <code>mkdtemp</code> cannot clash with temporary
 files or directories created by other users.  This is because directory
 creation always works like <code>open</code> with <code>O_EXCL</code>. 
-See <a href="#Creating%20Directories">Creating Directories</a>.
+See <a href="#Creating Directories">Creating Directories</a>.
 
 <p>The <code>mkdtemp</code> function comes from OpenBSD.
 
 <p><hr>
-Node:<a name="Pipes%20and%20FIFOs">Pipes and FIFOs</a>,
+Node:<a name="Pipes and FIFOs">Pipes and FIFOs</a>,
 Next:<a rel=next accesskey=n href="#Sockets">Sockets</a>,
-Previous:<a rel=previous accesskey=p href="#File%20System%20Interface">File System Interface</a>,
+Previous:<a rel=previous accesskey=p href="#File System Interface">File System Interface</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Pipes and FIFOs</h2>
@@ -37023,43 +36223,42 @@
 reading and writing operations happen sequentially; reading from the
 beginning of the file and writing at the end.
 
 <ul>
-<li><a accesskey=1 href="#Creating%20a%20Pipe">Creating a Pipe</a>:              Making a pipe with the <code>pipe</code> function. 
-<li><a accesskey=2 href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>:         Using a pipe to communicate with a
+<li><a accesskey=1 href="#Creating a Pipe">Creating a Pipe</a>:              Making a pipe with the <code>pipe</code> function. 
+<li><a accesskey=2 href="#Pipe to a Subprocess">Pipe to a Subprocess</a>:         Using a pipe to communicate with a
 				 child process. 
-<li><a accesskey=3 href="#FIFO%20Special%20Files">FIFO Special Files</a>:           Making a FIFO special file. 
-<li><a accesskey=4 href="#Pipe%20Atomicity">Pipe Atomicity</a>: 		When pipe (or FIFO) I/O is atomic. 
+<li><a accesskey=3 href="#FIFO Special Files">FIFO Special Files</a>:           Making a FIFO special file. 
+<li><a accesskey=4 href="#Pipe Atomicity">Pipe Atomicity</a>: 		When pipe (or FIFO) I/O is atomic. 
 </ul>
 
 <p><hr>
-Node:<a name="Creating%20a%20Pipe">Creating a Pipe</a>,
-Next:<a rel=next accesskey=n href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>,
-Up:<a rel=up accesskey=u href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>
+Node:<a name="Creating a Pipe">Creating a Pipe</a>,
+Next:<a rel=next accesskey=n href="#Pipe to a Subprocess">Pipe to a Subprocess</a>,
+Up:<a rel=up accesskey=u href="#Pipes and FIFOs">Pipes and FIFOs</a>
 <br>
 
 <h3>Creating a Pipe</h3>
 
 <p>The primitive for creating a pipe is the <code>pipe</code> function.  This
 creates both the reading and writing ends of the pipe.  It is not very
 useful for a single process to use a pipe to talk to itself.  In typical
 use, a process creates a pipe just before it forks one or more child
-processes (see <a href="#Creating%20a%20Process">Creating a Process</a>).  The pipe is then used for
+processes (see <a href="#Creating a Process">Creating a Process</a>).  The pipe is then used for
 communication either between the parent or child processes, or between
 two sibling processes.
 
 <p>The <code>pipe</code> function is declared in the header file
 <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>pipe</b><i> (int <var>filedes</var><tt>[2]</tt>)
-</i></td>
+<td align="left"><code>int <b>pipe</b><i> (int <var>filedes</var><tt>[2]</tt>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pipe</code> function creates a pipe and puts the file descriptors
 for the reading and writing ends of the pipe (respectively) into
 <code><var>filedes</var>[0]</code> and <code><var>filedes</var>[1]</code>.
@@ -37076,17 +36275,17 @@
 <dt><code>EMFILE</code>
 <dd>The process has too many files open.
 
 <br><dt><code>ENFILE</code>
-<dd>There are too many open files in the entire system.  See <a href="#Error%20Codes">Error Codes</a>,
+<dd>There are too many open files in the entire system.  See <a href="#Error Codes">Error Codes</a>,
 for more information about <code>ENFILE</code>.  This error never occurs in
 the GNU system. 
 </dl>
 </td></tr>
 </table>
 
 <p>Here is an example of a simple program that creates a pipe.  This program
-uses the <code>fork</code> function (see <a href="#Creating%20a%20Process">Creating a Process</a>) to create
+uses the <code>fork</code> function (see <a href="#Creating a Process">Creating a Process</a>) to create
 a child process.  The parent process writes data to the pipe, which is
 read by the child process.
 
 <br><pre>
@@ -37161,12 +36360,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>,
-Next:<a rel=next accesskey=n href="#FIFO%20Special%20Files">FIFO Special Files</a>,
-Previous:<a rel=previous accesskey=p href="#Creating%20a%20Pipe">Creating a Pipe</a>,
-Up:<a rel=up accesskey=u href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>
+Node:<a name="Pipe to a Subprocess">Pipe to a Subprocess</a>,
+Next:<a rel=next accesskey=n href="#FIFO Special Files">FIFO Special Files</a>,
+Previous:<a rel=previous accesskey=p href="#Creating a Pipe">Creating a Pipe</a>,
+Up:<a rel=up accesskey=u href="#Pipes and FIFOs">Pipes and FIFOs</a>
 <br>
 
 <h3>Pipe to a Subprocess</h3>
 
@@ -37181,19 +36380,18 @@
 interface is much simpler and easier to use.  But it doesn't offer as
 much flexibility as using the low-level functions directly.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>popen</b><i> (const char *<var>command</var>, const char *<var>mode</var>)
-</i></td>
+<td align="left"><code>FILE * <b>popen</b><i> (const char *<var>command</var>, const char *<var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>popen</code> function is closely related to the <code>system</code>
-function; see <a href="#Running%20a%20Command">Running a Command</a>.  It executes the shell command
+function; see <a href="#Running a Command">Running a Command</a>.  It executes the shell command
 <var>command</var> as a subprocess.  However, instead of waiting for the
 command to complete, it creates a pipe to the subprocess and returns a
 stream that corresponds to that pipe.
 
@@ -37212,16 +36410,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>pclose</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>pclose</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pclose</code> function is used to close a stream created by <code>popen</code>. 
 It waits for the child process to terminate and returns its status value,
 as for the <code>system</code> function. 
@@ -37272,12 +36469,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="FIFO%20Special%20Files">FIFO Special Files</a>,
-Next:<a rel=next accesskey=n href="#Pipe%20Atomicity">Pipe Atomicity</a>,
-Previous:<a rel=previous accesskey=p href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>,
-Up:<a rel=up accesskey=u href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>
+Node:<a name="FIFO Special Files">FIFO Special Files</a>,
+Next:<a rel=next accesskey=n href="#Pipe Atomicity">Pipe Atomicity</a>,
+Previous:<a rel=previous accesskey=p href="#Pipe to a Subprocess">Pipe to a Subprocess</a>,
+Up:<a rel=up accesskey=u href="#Pipes and FIFOs">Pipes and FIFOs</a>
 <br>
 
 <h3>FIFO Special Files</h3>
 
@@ -37296,24 +36493,23 @@
 <p>The <code>mkfifo</code> function is declared in the header file
 <code>sys/stat.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mkfifo</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>mkfifo</b><i> (const char *<var>filename</var>, mode_t <var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mkfifo</code> function makes a FIFO special file with name
 <var>filename</var>.  The <var>mode</var> argument is used to set the file's
-permissions; see <a href="#Setting%20Permissions">Setting Permissions</a>.
+permissions; see <a href="#Setting Permissions">Setting Permissions</a>.
 
 <p>The normal, successful return value from <code>mkfifo</code> is <code>0</code>.  In
 the case of an error, <code>-1</code> is returned.  In addition to the usual
-file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following
+file name errors (see <a href="#File Name Errors">File Name Errors</a>), the following
 <code>errno</code> error conditions are defined for this function:
 
 <dl>
 <dt><code>EEXIST</code>
@@ -37329,11 +36525,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Pipe%20Atomicity">Pipe Atomicity</a>,
-Previous:<a rel=previous accesskey=p href="#FIFO%20Special%20Files">FIFO Special Files</a>,
-Up:<a rel=up accesskey=u href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>
+Node:<a name="Pipe Atomicity">Pipe Atomicity</a>,
+Previous:<a rel=previous accesskey=p href="#FIFO Special Files">FIFO Special Files</a>,
+Up:<a rel=up accesskey=u href="#Pipes and FIFOs">Pipes and FIFOs</a>
 <br>
 
 <h3>Atomicity of Pipe I/O</h3>
 
@@ -37348,15 +36544,15 @@
 example, output data from other processes sharing the descriptor may be
 interspersed.  Also, once <code>PIPE_BUF</code> characters have been written,
 further writes will block until some characters are read.
 
-<p>See <a href="#Limits%20for%20Files">Limits for Files</a>, for information about the <code>PIPE_BUF</code>
+<p>See <a href="#Limits for Files">Limits for Files</a>, for information about the <code>PIPE_BUF</code>
 parameter.
 
 <p><hr>
 Node:<a name="Sockets">Sockets</a>,
-Next:<a rel=next accesskey=n href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>,
-Previous:<a rel=previous accesskey=p href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>,
+Next:<a rel=next accesskey=n href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>,
+Previous:<a rel=previous accesskey=p href="#Pipes and FIFOs">Pipes and FIFOs</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Sockets</h2>
@@ -37382,28 +36578,28 @@
 reentrant functions and some newer functions that are related to IPv6
 aren't documented either so far.
 
 <ul>
-<li><a accesskey=1 href="#Socket%20Concepts">Socket Concepts</a>: 	Basic concepts you need to know about. 
-<li><a accesskey=2 href="#Communication%20Styles">Communication Styles</a>: Stream communication, datagrams and other styles. 
-<li><a accesskey=3 href="#Socket%20Addresses">Socket Addresses</a>: 	How socket names (``addresses'') work. 
-<li><a accesskey=4 href="#Interface%20Naming">Interface Naming</a>: 	Identifying specific network interfaces. 
-<li><a accesskey=5 href="#Local%20Namespace">Local Namespace</a>: 	Details about the local namespace. 
-<li><a accesskey=6 href="#Internet%20Namespace">Internet Namespace</a>: 	Details about the Internet namespace. 
-<li><a accesskey=7 href="#Misc%20Namespaces">Misc Namespaces</a>: 	Other namespaces not documented fully here. 
-<li><a accesskey=8 href="#Open%2fClose%20Sockets">Open/Close Sockets</a>:   Creating sockets and destroying them. 
+<li><a accesskey=1 href="#Socket Concepts">Socket Concepts</a>: 	Basic concepts you need to know about. 
+<li><a accesskey=2 href="#Communication Styles">Communication Styles</a>: Stream communication, datagrams and other styles. 
+<li><a accesskey=3 href="#Socket Addresses">Socket Addresses</a>: 	How socket names ("addresses") work. 
+<li><a accesskey=4 href="#Interface Naming">Interface Naming</a>: 	Identifying specific network interfaces. 
+<li><a accesskey=5 href="#Local Namespace">Local Namespace</a>: 	Details about the local namespace. 
+<li><a accesskey=6 href="#Internet Namespace">Internet Namespace</a>: 	Details about the Internet namespace. 
+<li><a accesskey=7 href="#Misc Namespaces">Misc Namespaces</a>: 	Other namespaces not documented fully here. 
+<li><a accesskey=8 href="#Open%2fClose Sockets">Open/Close Sockets</a>:   Creating sockets and destroying them. 
 <li><a accesskey=9 href="#Connections">Connections</a>: 		Operations on sockets with connection state. 
 <li><a href="#Datagrams">Datagrams</a>: 		Operations on datagram sockets. 
 <li><a href="#Inetd">Inetd</a>: 		Inetd is a daemon that starts servers on request. 
 			   The most convenient way to write a server
 			   is to make it work with Inetd. 
-<li><a href="#Socket%20Options">Socket Options</a>: 	Miscellaneous low-level socket options. 
-<li><a href="#Networks%20Database">Networks Database</a>:    Accessing the database of network names. 
+<li><a href="#Socket Options">Socket Options</a>: 	Miscellaneous low-level socket options. 
+<li><a href="#Networks Database">Networks Database</a>:    Accessing the database of network names. 
 </ul>
 
 <p><hr>
-Node:<a name="Socket%20Concepts">Socket Concepts</a>,
-Next:<a rel=next accesskey=n href="#Communication%20Styles">Communication Styles</a>,
+Node:<a name="Socket Concepts">Socket Concepts</a>,
+Next:<a rel=next accesskey=n href="#Communication Styles">Communication Styles</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Socket Concepts</h3>
@@ -37492,11 +36688,11 @@
 which require that references to 32-bit variables be passed can be as
 happy as implementations which use 64-bit values.
 
 <p><hr>
-Node:<a name="Communication%20Styles">Communication Styles</a>,
-Next:<a rel=next accesskey=n href="#Socket%20Addresses">Socket Addresses</a>,
-Previous:<a rel=previous accesskey=p href="#Socket%20Concepts">Socket Concepts</a>,
+Node:<a name="Communication Styles">Communication Styles</a>,
+Next:<a rel=next accesskey=n href="#Socket Addresses">Socket Addresses</a>,
+Previous:<a rel=previous accesskey=p href="#Socket Concepts">Socket Concepts</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Communication Styles</h3>
@@ -37506,34 +36702,32 @@
 supported socket types.  The symbolic constants listed here are
 defined in <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SOCK_STREAM</b><i>
-</i></td>
+<td align="left"><code>int <b>SOCK_STREAM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-The <code>SOCK_STREAM</code> style is like a pipe (see <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>). 
+The <code>SOCK_STREAM</code> style is like a pipe (see <a href="#Pipes and FIFOs">Pipes and FIFOs</a>). 
 It operates over a connection with a particular remote socket and
 transmits data reliably as a stream of bytes.
 
 <p>Use of this style is covered in detail in <a href="#Connections">Connections</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SOCK_DGRAM</b><i>
-</i></td>
+<td align="left"><code>int <b>SOCK_DGRAM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SOCK_DGRAM</code> style is used for sending
 individually-addressed packets unreliably. 
 It is the diametrical opposite of <code>SOCK_STREAM</code>.
@@ -37557,27 +36751,26 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SOCK_RAW</b><i>
-</i></td>
+<td align="left"><code>int <b>SOCK_RAW</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This style provides access to low-level network protocols and
 interfaces.  Ordinary user programs usually have no need to use this
 style. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Socket%20Addresses">Socket Addresses</a>,
-Next:<a rel=next accesskey=n href="#Interface%20Naming">Interface Naming</a>,
-Previous:<a rel=previous accesskey=p href="#Communication%20Styles">Communication Styles</a>,
+Node:<a name="Socket Addresses">Socket Addresses</a>,
+Next:<a rel=next accesskey=n href="#Interface Naming">Interface Naming</a>,
+Previous:<a rel=previous accesskey=p href="#Communication Styles">Communication Styles</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Socket Addresses</h3>
@@ -37604,9 +36797,9 @@
 protocols look at the client's socket address and only bypass password
 checking if it is less than <code>IPPORT_RESERVED</code> (see <a href="#Ports">Ports</a>).
 
 <p>The details of socket addresses vary depending on what namespace you are
-using.  See <a href="#Local%20Namespace">Local Namespace</a>, or <a href="#Internet%20Namespace">Internet Namespace</a>, for specific
+using.  See <a href="#Local Namespace">Local Namespace</a>, or <a href="#Internet Namespace">Internet Namespace</a>, for specific
 information.
 
 <p>Regardless of the namespace, you use the same functions <code>bind</code> and
 <code>getsockname</code> to set and examine a socket's address.  These
@@ -37616,17 +36809,17 @@
 its address to <code>struct sockaddr *</code> when you pass it to
 <code>bind</code>.
 
 <ul>
-<li><a accesskey=1 href="#Address%20Formats">Address Formats</a>: 		About <code>struct sockaddr</code>. 
-<li><a accesskey=2 href="#Setting%20Address">Setting Address</a>: 		Binding an address to a socket. 
-<li><a accesskey=3 href="#Reading%20Address">Reading Address</a>: 		Reading the address of a socket. 
+<li><a accesskey=1 href="#Address Formats">Address Formats</a>: 		About <code>struct sockaddr</code>. 
+<li><a accesskey=2 href="#Setting Address">Setting Address</a>: 		Binding an address to a socket. 
+<li><a accesskey=3 href="#Reading Address">Reading Address</a>: 		Reading the address of a socket. 
 </ul>
 
 <p><hr>
-Node:<a name="Address%20Formats">Address Formats</a>,
-Next:<a rel=next accesskey=n href="#Setting%20Address">Setting Address</a>,
-Up:<a rel=up accesskey=u href="#Socket%20Addresses">Socket Addresses</a>
+Node:<a name="Address Formats">Address Formats</a>,
+Next:<a rel=next accesskey=n href="#Setting Address">Setting Address</a>,
+Up:<a rel=up accesskey=u href="#Socket Addresses">Socket Addresses</a>
 <br>
 
 <h4>Address Formats</h4>
 
@@ -37647,16 +36840,15 @@
 <p>The symbols in this section are defined in the header file
 <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sockaddr</b><i>
-</i></td>
+<td align="left"><code><b>struct sockaddr</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>struct sockaddr</code> type itself has the following members:
 
 <dl>
@@ -37678,9 +36870,9 @@
 
 <dl>
 <dt><code>AF_LOCAL</code>
 <dd>This designates the address format that goes with the local namespace. 
-(<code>PF_LOCAL</code> is the name of that namespace.)  See <a href="#Local%20Namespace%20Details">Local Namespace Details</a>, for information about this address format.
+(<code>PF_LOCAL</code> is the name of that namespace.)  See <a href="#Local Namespace Details">Local Namespace Details</a>, for information about this address format.
 
 <br><dt><code>AF_UNIX</code>
 <dd>This is a synonym for <code>AF_LOCAL</code>.  Although <code>AF_LOCAL</code> is
 mandated by POSIX.1g, <code>AF_UNIX</code> is portable to more systems. 
@@ -37695,18 +36887,18 @@
 
 <br><dt><code>AF_INET</code>
 <dd>This designates the address format that goes with the Internet
 namespace.  (<code>PF_INET</code> is the name of that namespace.) 
-See <a href="#Internet%20Address%20Formats">Internet Address Formats</a>.
+See <a href="#Internet Address Formats">Internet Address Formats</a>.
 
 <br><dt><code>AF_INET6</code>
 <dd>This is similar to <code>AF_INET</code>, but refers to the IPv6 protocol. 
 (<code>PF_INET6</code> is the name of the corresponding namespace.)
 
 <br><dt><code>AF_UNSPEC</code>
 <dd>This designates no particular address format.  It is used only in rare
 cases, such as to clear out the default destination address of a
-"connected" datagram socket.  See <a href="#Sending%20Datagrams">Sending Datagrams</a>.
+"connected" datagram socket.  See <a href="#Sending Datagrams">Sending Datagrams</a>.
 
 <p>The corresponding namespace designator symbol <code>PF_UNSPEC</code> exists
 for completeness, but there is no reason to use it in a program. 
 </dl>
@@ -37716,29 +36908,28 @@
 implemented.  We will document those that really work as we receive
 information about how to use them.
 
 <p><hr>
-Node:<a name="Setting%20Address">Setting Address</a>,
-Next:<a rel=next accesskey=n href="#Reading%20Address">Reading Address</a>,
-Previous:<a rel=previous accesskey=p href="#Address%20Formats">Address Formats</a>,
-Up:<a rel=up accesskey=u href="#Socket%20Addresses">Socket Addresses</a>
+Node:<a name="Setting Address">Setting Address</a>,
+Next:<a rel=next accesskey=n href="#Reading Address">Reading Address</a>,
+Previous:<a rel=previous accesskey=p href="#Address Formats">Address Formats</a>,
+Up:<a rel=up accesskey=u href="#Socket Addresses">Socket Addresses</a>
 <br>
 
 <h4>Setting the Address of a Socket</h4>
 
 <p>Use the <code>bind</code> function to assign an address to a socket.  The
 prototype for <code>bind</code> is in the header file <code>sys/socket.h</code>. 
-For examples of use, see <a href="#Local%20Socket%20Example">Local Socket Example</a>, or see <a href="#Inet%20Example">Inet Example</a>.
+For examples of use, see <a href="#Local Socket Example">Local Socket Example</a>, or see <a href="#Inet Example">Inet Example</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>bind</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>bind</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>bind</code> function assigns an address to the socket
 <var>socket</var>.  The <var>addr</var> and <var>length</var> arguments specify the
 address; the detailed format of the address depends on the namespace. 
@@ -37777,11 +36968,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Reading%20Address">Reading Address</a>,
-Previous:<a rel=previous accesskey=p href="#Setting%20Address">Setting Address</a>,
-Up:<a rel=up accesskey=u href="#Socket%20Addresses">Socket Addresses</a>
+Node:<a name="Reading Address">Reading Address</a>,
+Previous:<a rel=previous accesskey=p href="#Setting Address">Setting Address</a>,
+Up:<a rel=up accesskey=u href="#Socket Addresses">Socket Addresses</a>
 <br>
 
 <h4>Reading the Address of a Socket</h4>
 
@@ -37789,16 +36980,15 @@
 Internet socket.  The prototype for this function is in the header file
 <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getsockname</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>getsockname</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getsockname</code> function returns information about the
 address of the socket <var>socket</var> in the locations specified by the
 <var>addr</var> and <var>length-ptr</var> arguments.  Note that the
@@ -37833,11 +37023,11 @@
 consistent with the rest of the system; in general, there's no way to
 find a file's name from a descriptor for that file.
 
 <p><hr>
-Node:<a name="Interface%20Naming">Interface Naming</a>,
-Next:<a rel=next accesskey=n href="#Local%20Namespace">Local Namespace</a>,
-Previous:<a rel=previous accesskey=p href="#Socket%20Addresses">Socket Addresses</a>,
+Node:<a name="Interface Naming">Interface Naming</a>,
+Next:<a rel=next accesskey=n href="#Local Namespace">Local Namespace</a>,
+Previous:<a rel=previous accesskey=p href="#Socket Addresses">Socket Addresses</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Interface Naming</h3>
@@ -37856,46 +37046,43 @@
 <p>The following functions, constants and data types are declared in the
 header file <code>net/if.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>IFNAMSIZ</b><i>
-</i></td>
+<td align="left"><code>size_t <b>IFNAMSIZ</b><i></i></code></td>
 <td align="right">Constant</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant defines the maximum buffer size needed to hold an
 interface name, including its terminating zero byte. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned int <b>if_nametoindex</b><i> (const char *ifname)
-</i></td>
+<td align="left"><code>unsigned int <b>if_nametoindex</b><i> (const char *ifname)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function yields the interface index corresponding to a particular
 name.  If no interface exists with the name given, it returns 0. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>if_indextoname</b><i> (unsigned int ifindex, char *ifname)
-</i></td>
+<td align="left"><code>char * <b>if_indextoname</b><i> (unsigned int ifindex, char *ifname)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function maps an interface index to its corresponding name.  The
 returned name is placed in the buffer pointed to by <code>ifname</code>, which
 must be at least <code>IFNAMSIZ</code> bytes in length.  If the index was
@@ -37904,16 +37091,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct if_nameindex</b><i>
-</i></td>
+<td align="left"><code><b>struct if_nameindex</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used to hold the information about a single
 interface.  It has the following members:
 
@@ -37928,16 +37114,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct if_nameindex * <b>if_nameindex</b><i> (void)
-</i></td>
+<td align="left"><code>struct if_nameindex * <b>if_nameindex</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns an array of <code>if_nameindex</code> structures, one
 for every interface that is present.  The end of the list is indicated
 by a structure with an interface of 0 and a null name pointer.  If an
@@ -37948,26 +37133,25 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>if_freenameindex</b><i> (struct if_nameindex *ptr)
-</i></td>
+<td align="left"><code>void <b>if_freenameindex</b><i> (struct if_nameindex *ptr)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function frees the structure returned by an earlier call to
 <code>if_nameindex</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Local%20Namespace">Local Namespace</a>,
-Next:<a rel=next accesskey=n href="#Internet%20Namespace">Internet Namespace</a>,
-Previous:<a rel=previous accesskey=p href="#Interface%20Naming">Interface Naming</a>,
+Node:<a name="Local Namespace">Local Namespace</a>,
+Next:<a rel=next accesskey=n href="#Internet Namespace">Internet Namespace</a>,
+Previous:<a rel=previous accesskey=p href="#Interface Naming">Interface Naming</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>The Local Namespace</h3>
@@ -37978,17 +37162,17 @@
 name is file namespace since socket addresses are normally implemented
 as file names.
 
 <ul>
-<li><a accesskey=1 href="#Local%20Namespace%20Concepts">Concepts</a>:  What you need to understand. 
-<li><a accesskey=2 href="#Local%20Namespace%20Details">Details</a>:    Address format, symbolic names, etc. 
-<li><a accesskey=3 href="#Local%20Socket%20Example">Example</a>:       Example of creating a socket. 
+<li><a accesskey=1 href="#Local Namespace Concepts">Concepts</a>:  What you need to understand. 
+<li><a accesskey=2 href="#Local Namespace Details">Details</a>:    Address format, symbolic names, etc. 
+<li><a accesskey=3 href="#Local Socket Example">Example</a>:       Example of creating a socket. 
 </ul>
 
 <p><hr>
-Node:<a name="Local%20Namespace%20Concepts">Local Namespace Concepts</a>,
-Next:<a rel=next accesskey=n href="#Local%20Namespace%20Details">Local Namespace Details</a>,
-Up:<a rel=up accesskey=u href="#Local%20Namespace">Local Namespace</a>
+Node:<a name="Local Namespace Concepts">Local Namespace Concepts</a>,
+Next:<a rel=next accesskey=n href="#Local Namespace Details">Local Namespace Details</a>,
+Up:<a rel=up accesskey=u href="#Local Namespace">Local Namespace</a>
 <br>
 
 <h4>Local Namespace Concepts</h4>
 
@@ -38013,18 +37197,18 @@
 number if you want it to have one.
 
 <p>After you close a socket in the local namespace, you should delete the
 file name from the file system.  Use <code>unlink</code> or <code>remove</code> to
-do this; see <a href="#Deleting%20Files">Deleting Files</a>.
+do this; see <a href="#Deleting Files">Deleting Files</a>.
 
 <p>The local namespace supports just one protocol for any communication
 style; it is protocol number <code>0</code>.
 
 <p><hr>
-Node:<a name="Local%20Namespace%20Details">Local Namespace Details</a>,
-Next:<a rel=next accesskey=n href="#Local%20Socket%20Example">Local Socket Example</a>,
-Previous:<a rel=previous accesskey=p href="#Local%20Namespace%20Concepts">Local Namespace Concepts</a>,
-Up:<a rel=up accesskey=u href="#Local%20Namespace">Local Namespace</a>
+Node:<a name="Local Namespace Details">Local Namespace Details</a>,
+Next:<a rel=next accesskey=n href="#Local Socket Example">Local Socket Example</a>,
+Previous:<a rel=previous accesskey=p href="#Local Namespace Concepts">Local Namespace Concepts</a>,
+Up:<a rel=up accesskey=u href="#Local Namespace">Local Namespace</a>
 <br>
 
 <h4>Details of Local Namespace</h4>
 
@@ -38032,46 +37216,43 @@
 <code>PF_LOCAL</code> as the <var>namespace</var> argument to <code>socket</code> or
 <code>socketpair</code>.  This constant is defined in <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PF_LOCAL</b><i>
-</i></td>
+<td align="left"><code>int <b>PF_LOCAL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This designates the local namespace, in which socket addresses are local
 names, and its associated family of protocols.  <code>PF_Local</code> is the
 macro used by Posix.1g. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PF_UNIX</b><i>
-</i></td>
+<td align="left"><code>int <b>PF_UNIX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a synonym for <code>PF_LOCAL</code>, for compatibility's sake. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PF_FILE</b><i>
-</i></td>
+<td align="left"><code>int <b>PF_FILE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a synonym for <code>PF_LOCAL</code>, for compatibility's sake. 
 </td></tr>
 </table>
@@ -38079,25 +37260,24 @@
 <p>The structure for specifying socket names in the local namespace is
 defined in the header file <code>sys/un.h</code>:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sockaddr_un</b><i>
-</i></td>
+<td align="left"><code><b>struct sockaddr_un</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used to specify local namespace socket addresses.  It has
 the following members:
 
 <dl>
 <dt><code>short int sun_family</code>
 <dd>This identifies the address family or format of the socket address. 
 You should store the value <code>AF_LOCAL</code> to designate the local
-namespace.  See <a href="#Socket%20Addresses">Socket Addresses</a>.
+namespace.  See <a href="#Socket Addresses">Socket Addresses</a>.
 
 <br><dt><code>char sun_path[108]</code>
 <dd>This is the file name to use.
 
@@ -38114,25 +37294,24 @@
 component and the string length (<em>not</em> the allocation size!) of
 the file name string.  This can be done using the macro <code>SUN_LEN</code>:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SUN_LEN</b><i> (<em>struct sockaddr_un *</em> <var>ptr</var>)
-</i></td>
+<td align="left"><code>int <b>SUN_LEN</b><i> (<em>struct sockaddr_un *</em> <var>ptr</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The macro computes the length of socket address in the local namespace. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Local%20Socket%20Example">Local Socket Example</a>,
-Previous:<a rel=previous accesskey=p href="#Local%20Namespace%20Details">Local Namespace Details</a>,
-Up:<a rel=up accesskey=u href="#Local%20Namespace">Local Namespace</a>
+Node:<a name="Local Socket Example">Local Socket Example</a>,
+Previous:<a rel=previous accesskey=p href="#Local Namespace Details">Local Namespace Details</a>,
+Up:<a rel=up accesskey=u href="#Local Namespace">Local Namespace</a>
 <br>
 
 <h4>Example of Local-Namespace Sockets</h4>
 
@@ -38187,11 +37366,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Internet%20Namespace">Internet Namespace</a>,
-Next:<a rel=next accesskey=n href="#Misc%20Namespaces">Misc Namespaces</a>,
-Previous:<a rel=previous accesskey=p href="#Local%20Namespace">Local Namespace</a>,
+Node:<a name="Internet Namespace">Internet Namespace</a>,
+Next:<a rel=next accesskey=n href="#Misc Namespaces">Misc Namespaces</a>,
+Previous:<a rel=previous accesskey=p href="#Local Namespace">Local Namespace</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>The Internet Namespace</h3>
@@ -38210,31 +37389,29 @@
 <code>socket</code> or <code>socketpair</code>.  For IPv6 addresses you need the
 macro <code>PF_INET6</code>. These macros are defined in <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PF_INET</b><i>
-</i></td>
+<td align="left"><code>int <b>PF_INET</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This designates the IPv4 Internet namespace and associated family of
 protocols. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PF_INET6</b><i>
-</i></td>
+<td align="left"><code>int <b>PF_INET6</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This designates the IPv6 Internet namespace and associated family of
 protocols. 
 </td></tr>
@@ -38243,34 +37420,34 @@
 <p>A socket address for the Internet namespace includes the following components:
 
 <ul>
 <li>The address of the machine you want to connect to.  Internet addresses
-can be specified in several ways; these are discussed in <a href="#Internet%20Address%20Formats">Internet Address Formats</a>, <a href="#Host%20Addresses">Host Addresses</a> and <a href="#Host%20Names">Host Names</a>.
+can be specified in several ways; these are discussed in <a href="#Internet Address Formats">Internet Address Formats</a>, <a href="#Host Addresses">Host Addresses</a> and <a href="#Host Names">Host Names</a>.
 
 <li>A port number for that machine.  See <a href="#Ports">Ports</a>. 
 </ul>
 
 <p>You must ensure that the address and port number are represented in a
-canonical format called <dfn>network byte order</dfn>.  See <a href="#Byte%20Order">Byte Order</a>,
+canonical format called <dfn>network byte order</dfn>.  See <a href="#Byte Order">Byte Order</a>,
 for information about this.
 
 <ul>
-<li><a accesskey=1 href="#Internet%20Address%20Formats">Internet Address Formats</a>:     How socket addresses are specified in the
+<li><a accesskey=1 href="#Internet Address Formats">Internet Address Formats</a>:     How socket addresses are specified in the
                                  Internet namespace. 
-<li><a accesskey=2 href="#Host%20Addresses">Host Addresses</a>: 	        All about host addresses of Internet host. 
-<li><a accesskey=3 href="#Protocols%20Database">Protocols Database</a>: 		Referring to protocols by name. 
+<li><a accesskey=2 href="#Host Addresses">Host Addresses</a>: 	        All about host addresses of Internet host. 
+<li><a accesskey=3 href="#Protocols Database">Protocols Database</a>: 		Referring to protocols by name. 
 <li><a accesskey=4 href="#Ports">Ports</a>: 			Internet port numbers. 
-<li><a accesskey=5 href="#Services%20Database">Services Database</a>:            Ports may have symbolic names. 
-<li><a accesskey=6 href="#Byte%20Order">Byte Order</a>: 		        Different hosts may use different byte
+<li><a accesskey=5 href="#Services Database">Services Database</a>:            Ports may have symbolic names. 
+<li><a accesskey=6 href="#Byte Order">Byte Order</a>: 		        Different hosts may use different byte
                                  ordering conventions; you need to
                                  canonicalize host address and port number. 
-<li><a accesskey=7 href="#Inet%20Example">Inet Example</a>: 	        Putting it all together. 
+<li><a accesskey=7 href="#Inet Example">Inet Example</a>: 	        Putting it all together. 
 </ul>
 
 <p><hr>
-Node:<a name="Internet%20Address%20Formats">Internet Address Formats</a>,
-Next:<a rel=next accesskey=n href="#Host%20Addresses">Host Addresses</a>,
-Up:<a rel=up accesskey=u href="#Internet%20Namespace">Internet Namespace</a>
+Node:<a name="Internet Address Formats">Internet Address Formats</a>,
+Next:<a rel=next accesskey=n href="#Host Addresses">Host Addresses</a>,
+Up:<a rel=up accesskey=u href="#Internet Namespace">Internet Namespace</a>
 <br>
 
 <h4>Internet Socket Address Formats</h4>
 
@@ -38283,28 +37460,27 @@
 <p>The data types for representing socket addresses in the Internet namespace
 are defined in the header file <code>netinet/in.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sockaddr_in</b><i>
-</i></td>
+<td align="left"><code><b>struct sockaddr_in</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type used to represent socket addresses in the
 Internet namespace.  It has the following members:
 
 <dl>
 <dt><code>sa_family_t sin_family</code>
 <dd>This identifies the address family or format of the socket address. 
 You should store the value <code>AF_INET</code> in this member. 
-See <a href="#Socket%20Addresses">Socket Addresses</a>.
+See <a href="#Socket Addresses">Socket Addresses</a>.
 
 <br><dt><code>struct in_addr sin_addr</code>
-<dd>This is the Internet address of the host machine.  See <a href="#Host%20Addresses">Host Addresses</a>, and <a href="#Host%20Names">Host Names</a>, for how to get a value to store
+<dd>This is the Internet address of the host machine.  See <a href="#Host Addresses">Host Addresses</a>, and <a href="#Host Names">Host Names</a>, for how to get a value to store
 here.
 
 <br><dt><code>unsigned short int sin_port</code>
 <dd>This is the port number.  See <a href="#Ports">Ports</a>. 
@@ -38316,28 +37492,27 @@
 <code>sizeof (struct sockaddr_in)</code> as the <var>length</var> parameter if
 you are using an IPv4 Internet namespace socket address.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sockaddr_in6</b><i>
-</i></td>
+<td align="left"><code><b>struct sockaddr_in6</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type used to represent socket addresses in the IPv6
 namespace.  It has the following members:
 
 <dl>
 <dt><code>sa_family_t sin6_family</code>
 <dd>This identifies the address family or format of the socket address. 
 You should store the value of <code>AF_INET6</code> in this member. 
-See <a href="#Socket%20Addresses">Socket Addresses</a>.
+See <a href="#Socket Addresses">Socket Addresses</a>.
 
 <br><dt><code>struct in6_addr sin6_addr</code>
-<dd>This is the IPv6 address of the host machine.  See <a href="#Host%20Addresses">Host Addresses</a>, and <a href="#Host%20Names">Host Names</a>, for how to get a value to store
+<dd>This is the IPv6 address of the host machine.  See <a href="#Host Addresses">Host Addresses</a>, and <a href="#Host Names">Host Names</a>, for how to get a value to store
 here.
 
 <br><dt><code>uint32_t sin6_flowinfo</code>
 <dd>This is a currently unimplemented field.
@@ -38349,12 +37524,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Host%20Addresses">Host Addresses</a>,
-Next:<a rel=next accesskey=n href="#Protocols%20Database">Protocols Database</a>,
-Previous:<a rel=previous accesskey=p href="#Internet%20Address%20Formats">Internet Address Formats</a>,
-Up:<a rel=up accesskey=u href="#Internet%20Namespace">Internet Namespace</a>
+Node:<a name="Host Addresses">Host Addresses</a>,
+Next:<a rel=next accesskey=n href="#Protocols Database">Protocols Database</a>,
+Previous:<a rel=previous accesskey=p href="#Internet Address Formats">Internet Address Formats</a>,
+Up:<a rel=up accesskey=u href="#Internet Namespace">Internet Namespace</a>
 <br>
 
 <h4>Host Addresses</h4>
 
@@ -38373,18 +37548,18 @@
 numeric address, and so must convert a host name to the numeric address
 it stands for.
 
 <ul>
-<li><a accesskey=1 href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>: 	What a host number consists of. 
-<li><a accesskey=2 href="#Host%20Address%20Data%20Type">Data type</a>: 	Data type for a host number. 
-<li><a accesskey=3 href="#Host%20Address%20Functions">Functions</a>: 	Functions to operate on them. 
-<li><a accesskey=4 href="#Host%20Names">Names</a>: 		Translating host names to host numbers. 
+<li><a accesskey=1 href="#Abstract Host Addresses">Abstract Host Addresses</a>: 	What a host number consists of. 
+<li><a accesskey=2 href="#Host Address Data Type">Data type</a>: 	Data type for a host number. 
+<li><a accesskey=3 href="#Host Address Functions">Functions</a>: 	Functions to operate on them. 
+<li><a accesskey=4 href="#Host Names">Names</a>: 		Translating host names to host numbers. 
 </ul>
 
 <p><hr>
-Node:<a name="Abstract%20Host%20Addresses">Abstract Host Addresses</a>,
-Next:<a rel=next accesskey=n href="#Host%20Address%20Data%20Type">Host Address Data Type</a>,
-Up:<a rel=up accesskey=u href="#Host%20Addresses">Host Addresses</a>
+Node:<a name="Abstract Host Addresses">Abstract Host Addresses</a>,
+Next:<a rel=next accesskey=n href="#Host Address Data Type">Host Address Data Type</a>,
+Up:<a rel=up accesskey=u href="#Host Addresses">Host Addresses</a>
 <br>
 
 <h5>Internet Host Addresses</h5>
 
@@ -38478,12 +37653,12 @@
 consecutive zeros.  For example, the IPv6 loopback address
 <code>0:0:0:0:0:0:0:1</code> can just be written as <code>::1</code>.
 
 <p><hr>
-Node:<a name="Host%20Address%20Data%20Type">Host Address Data Type</a>,
-Next:<a rel=next accesskey=n href="#Host%20Address%20Functions">Host Address Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>,
-Up:<a rel=up accesskey=u href="#Host%20Addresses">Host Addresses</a>
+Node:<a name="Host Address Data Type">Host Address Data Type</a>,
+Next:<a rel=next accesskey=n href="#Host Address Functions">Host Address Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Abstract Host Addresses">Abstract Host Addresses</a>,
+Up:<a rel=up accesskey=u href="#Host Addresses">Host Addresses</a>
 <br>
 
 <h5>Host Address Data Type</h5>
 
@@ -38507,32 +37682,30 @@
 <p>The following basic definitions for Internet addresses are declared in
 the header file <code>netinet/in.h</code>:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct in_addr</b><i>
-</i></td>
+<td align="left"><code><b>struct in_addr</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used in certain contexts to contain an IPv4 Internet
 host address.  It has just one field, named <code>s_addr</code>, which records
 the host address number as an <code>uint32_t</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>INADDR_LOOPBACK</b><i>
-</i></td>
+<td align="left"><code>uint32_t <b>INADDR_LOOPBACK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 You can use this constant to stand for "the address of this machine,"
 instead of finding its actual address.  It is the IPv4 Internet address
 <code>127.0.0.1</code>, which is usually called <code>localhost</code>.  This
@@ -38543,75 +37716,70 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>INADDR_ANY</b><i>
-</i></td>
+<td align="left"><code>uint32_t <b>INADDR_ANY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 You can use this constant to stand for "any incoming address" when
-binding to an address.  See <a href="#Setting%20Address">Setting Address</a>.  This is the usual
+binding to an address.  See <a href="#Setting Address">Setting Address</a>.  This is the usual
 address to give in the <code>sin_addr</code> member of <code>struct&nbsp;sockaddr_in</code> when you want to accept Internet connections. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>INADDR_BROADCAST</b><i>
-</i></td>
+<td align="left"><code>uint32_t <b>INADDR_BROADCAST</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant is the address you use to send a broadcast message. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>INADDR_NONE</b><i>
-</i></td>
+<td align="left"><code>uint32_t <b>INADDR_NONE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant is returned by some functions to indicate an error. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct in6_addr</b><i>
-</i></td>
+<td align="left"><code><b>struct in6_addr</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used to store an IPv6 address.  It stores 128 bits of
 data, which can be accessed (via a union) in a variety of ways. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct in6_addr <b>in6addr_loopback</b><i>
-</i></td>
+<td align="left"><code>struct in6_addr <b>in6addr_loopback</b><i></i></code></td>
 <td align="right">Constant</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant is the IPv6 address <code>::1</code>, the loopback address.  See
 above for a description of what this means.  The macro
 <code>IN6ADDR_LOOPBACK_INIT</code> is provided to allow you to initialize your
@@ -38619,16 +37787,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct in6_addr <b>in6addr_any</b><i>
-</i></td>
+<td align="left"><code>struct in6_addr <b>in6addr_any</b><i></i></code></td>
 <td align="right">Constant</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant is the IPv6 address <code>::</code>, the unspecified address.  See
 above for a description of what this means.  The macro
 <code>IN6ADDR_ANY_INIT</code> is provided to allow you to initialize your
@@ -38636,30 +37803,29 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Host%20Address%20Functions">Host Address Functions</a>,
-Next:<a rel=next accesskey=n href="#Host%20Names">Host Names</a>,
-Previous:<a rel=previous accesskey=p href="#Host%20Address%20Data%20Type">Host Address Data Type</a>,
-Up:<a rel=up accesskey=u href="#Host%20Addresses">Host Addresses</a>
+Node:<a name="Host Address Functions">Host Address Functions</a>,
+Next:<a rel=next accesskey=n href="#Host Names">Host Names</a>,
+Previous:<a rel=previous accesskey=p href="#Host Address Data Type">Host Address Data Type</a>,
+Up:<a rel=up accesskey=u href="#Host Addresses">Host Addresses</a>
 <br>
 
 <h5>Host Address Functions</h5>
 
 <p>These additional functions for manipulating Internet addresses are
 declared in the header file <code>arpa/inet.h</code>.  They represent Internet
 addresses in network byte order, and network numbers and
-local-address-within-network numbers in host byte order.  See <a href="#Byte%20Order">Byte Order</a>, for an explanation of network and host byte order.
+local-address-within-network numbers in host byte order.  See <a href="#Byte Order">Byte Order</a>, for an explanation of network and host byte order.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>inet_aton</b><i> (const char *<var>name</var>, struct in_addr *<var>addr</var>)
-</i></td>
+<td align="left"><code>int <b>inet_aton</b><i> (const char *<var>name</var>, struct in_addr *<var>addr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts the IPv4 Internet host address <var>name</var>
 from the standard numbers-and-dots notation into binary data and stores
 it in the <code>struct in_addr</code> that <var>addr</var> points to. 
@@ -38667,16 +37833,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>inet_addr</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>uint32_t <b>inet_addr</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts the IPv4 Internet host address <var>name</var> from the
 standard numbers-and-dots notation into binary data.  If the input is
 not valid, <code>inet_addr</code> returns <code>INADDR_NONE</code>.  This is an
@@ -38687,16 +37852,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>inet_network</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>uint32_t <b>inet_network</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function extracts the network number from the address <var>name</var>,
 given in the standard numbers-and-dots notation. The returned address is
 in host order. If the input is not valid, <code>inet_network</code> returns
@@ -38708,16 +37872,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>inet_ntoa</b><i> (struct in_addr <var>addr</var>)
-</i></td>
+<td align="left"><code>char * <b>inet_ntoa</b><i> (struct in_addr <var>addr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts the IPv4 Internet host address <var>addr</var> to a
 string in the standard numbers-and-dots notation.  The return value is
 a pointer into a statically-allocated buffer.  Subsequent calls will
@@ -38734,32 +37897,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct in_addr <b>inet_makeaddr</b><i> (uint32_t <var>net</var>, uint32_t <var>local</var>)
-</i></td>
+<td align="left"><code>struct in_addr <b>inet_makeaddr</b><i> (uint32_t <var>net</var>, uint32_t <var>local</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function makes an IPv4 Internet host address by combining the network
 number <var>net</var> with the local-address-within-network number
 <var>local</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>inet_lnaof</b><i> (struct in_addr <var>addr</var>)
-</i></td>
+<td align="left"><code>uint32_t <b>inet_lnaof</b><i> (struct in_addr <var>addr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the local-address-within-network part of the
 Internet host address <var>addr</var>.
 
@@ -38769,16 +37930,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>inet_netof</b><i> (struct in_addr <var>addr</var>)
-</i></td>
+<td align="left"><code>uint32_t <b>inet_netof</b><i> (struct in_addr <var>addr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the network number part of the Internet host
 address <var>addr</var>.
 
@@ -38788,16 +37948,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>inet_pton</b><i> (int <var>af</var>, const char *<var>cp</var>, void *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>inet_pton</b><i> (int <var>af</var>, const char *<var>cp</var>, void *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts an Internet address (either IPv4 or IPv6) from
 presentation (textual) to network (binary) format.  <var>af</var> should be
 either <code>AF_INET</code> or <code>AF_INET6</code>, as appropriate for the type of
@@ -38807,16 +37966,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">const char * <b>inet_ntop</b><i> (int <var>af</var>, const void *<var>cp</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>const char * <b>inet_ntop</b><i> (int <var>af</var>, const void *<var>cp</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts an Internet address (either IPv4 or IPv6) from
 network (binary) to presentation (textual) form.  <var>af</var> should be
 either <code>AF_INET</code> or <code>AF_INET6</code>, as appropriate.  <var>cp</var> is a
@@ -38826,11 +37984,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Host%20Names">Host Names</a>,
-Previous:<a rel=previous accesskey=p href="#Host%20Address%20Functions">Host Address Functions</a>,
-Up:<a rel=up accesskey=u href="#Host%20Addresses">Host Addresses</a>
+Node:<a name="Host Names">Host Names</a>,
+Previous:<a rel=previous accesskey=p href="#Host Address Functions">Host Address Functions</a>,
+Up:<a rel=up accesskey=u href="#Host Addresses">Host Addresses</a>
 <br>
 
 <h5>Host Names</h5>
 
@@ -38848,16 +38006,15 @@
 in <code>netdb.h</code>.  They are BSD features, defined unconditionally if
 you include <code>netdb.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct hostent</b><i>
-</i></td>
+<td align="left"><code><b>struct hostent</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used to represent an entry in the hosts database.  It
 has the following members:
 
@@ -38874,9 +38031,9 @@
 <code>AF_INET</code> or <code>AF_INET6</code>, with the latter being used for IPv6
 hosts.  In principle other kinds of addresses could be represented in
 the database as well as Internet addresses; if this were done, you
 might find a value in this field other than <code>AF_INET</code> or
-<code>AF_INET6</code>.  See <a href="#Socket%20Addresses">Socket Addresses</a>.
+<code>AF_INET6</code>.  See <a href="#Socket Addresses">Socket Addresses</a>.
 
 <br><dt><code>int h_length</code>
 <dd>This is the length, in bytes, of each address.
 
@@ -38896,9 +38053,9 @@
 of memory <code>h_length</code> bytes long.  But in other contexts there is an
 implicit assumption that you can convert IPv4 addresses to a
 <code>struct in_addr</code> or an <code>uint32_t</code>.  Host addresses in
 a <code>struct hostent</code> structure are always given in network byte
-order; see <a href="#Byte%20Order">Byte Order</a>.
+order; see <a href="#Byte Order">Byte Order</a>.
 
 <p>You can use <code>gethostbyname</code>, <code>gethostbyname2</code> or
 <code>gethostbyaddr</code> to search the hosts database for information about
 a particular host.  The information is returned in a
@@ -38906,47 +38063,44 @@
 need to save it across calls.  You can also use <code>getaddrinfo</code> and
 <code>getnameinfo</code> to obtain this information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct hostent * <b>gethostbyname</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>struct hostent * <b>gethostbyname</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gethostbyname</code> function returns information about the host
 named <var>name</var>.  If the lookup fails, it returns a null pointer. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct hostent * <b>gethostbyname2</b><i> (const char *<var>name</var>, int <var>af</var>)
-</i></td>
+<td align="left"><code>struct hostent * <b>gethostbyname2</b><i> (const char *<var>name</var>, int <var>af</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gethostbyname2</code> function is like <code>gethostbyname</code>, but
 allows the caller to specify the desired address family (e.g. 
 <code>AF_INET</code> or <code>AF_INET6</code>) of the result. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct hostent * <b>gethostbyaddr</b><i> (const char *<var>addr</var>, size_t <var>length</var>, int <var>format</var>)
-</i></td>
+<td align="left"><code>struct hostent * <b>gethostbyaddr</b><i> (const char *<var>addr</var>, size_t <var>length</var>, int <var>format</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gethostbyaddr</code> function returns information about the host
 with Internet address <var>addr</var>.  The parameter <var>addr</var> is not
 really a pointer to char - it can be a pointer to an IPv4 or an IPv6
@@ -38988,16 +38142,15 @@
 Therefore provides the GNU C library a new set of functions which can be
 used in this context.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>gethostbyname_r</b><i> (const char *restrict <var>name</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)
-</i></td>
+<td align="left"><code>int <b>gethostbyname_r</b><i> (const char *restrict <var>name</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gethostbyname_r</code> function returns information about the host
 named <var>name</var>.  The caller must pass a pointer to an object of type
 <code>struct hostent</code> in the <var>result_buf</var> parameter.  In addition
@@ -39045,32 +38198,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>gethostbyname2_r</b><i> (const char *<var>name</var>, int <var>af</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)
-</i></td>
+<td align="left"><code>int <b>gethostbyname2_r</b><i> (const char *<var>name</var>, int <var>af</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gethostbyname2_r</code> function is like <code>gethostbyname_r</code>, but
 allows the caller to specify the desired address family (e.g. 
 <code>AF_INET</code> or <code>AF_INET6</code>) for the result. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>gethostbyaddr_r</b><i> (const char *<var>addr</var>, size_t <var>length</var>, int <var>format</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)
-</i></td>
+<td align="left"><code>int <b>gethostbyaddr_r</b><i> (const char *<var>addr</var>, size_t <var>length</var>, int <var>format</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gethostbyaddr_r</code> function returns information about the host
 with Internet address <var>addr</var>.  The parameter <var>addr</var> is not
 really a pointer to char - it can be a pointer to an IPv4 or an IPv6
@@ -39091,16 +38242,15 @@
 <code>sethostent</code>, <code>gethostent</code> and <code>endhostent</code>.  Be careful
 when using these functions because they are not reentrant.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>sethostent</b><i> (int <var>stayopen</var>)
-</i></td>
+<td align="left"><code>void <b>sethostent</b><i> (int <var>stayopen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens the hosts database to begin scanning it.  You can
 then call <code>gethostent</code> to read the entries.
 
@@ -39112,41 +38262,39 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct hostent * <b>gethostent</b><i> (void)
-</i></td>
+<td align="left"><code>struct hostent * <b>gethostent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next entry in the hosts database.  It
 returns a null pointer if there are no more entries. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endhostent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endhostent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the hosts database. 
 </td></tr>
 </table>
 
 <p><hr>
 Node:<a name="Ports">Ports</a>,
-Next:<a rel=next accesskey=n href="#Services%20Database">Services Database</a>,
-Previous:<a rel=previous accesskey=p href="#Protocols%20Database">Protocols Database</a>,
-Up:<a rel=up accesskey=u href="#Internet%20Namespace">Internet Namespace</a>
+Next:<a rel=next accesskey=n href="#Services Database">Services Database</a>,
+Previous:<a rel=previous accesskey=p href="#Protocols Database">Protocols Database</a>,
+Up:<a rel=up accesskey=u href="#Internet Namespace">Internet Namespace</a>
 <br>
 
 <h4>Internet Ports</h4>
 
@@ -39157,9 +38305,9 @@
 
 <p>Port numbers less than <code>IPPORT_RESERVED</code> are reserved for standard
 servers, such as <code>finger</code> and <code>telnet</code>.  There is a database
 that keeps track of these, and you can use the <code>getservbyname</code>
-function to map a service name onto a port number; see <a href="#Services%20Database">Services Database</a>.
+function to map a service name onto a port number; see <a href="#Services Database">Services Database</a>.
 
 <p>If you write a server that is not one of the standard ones defined in
 the database, you must choose a port number for it.  Use a number
 greater than <code>IPPORT_USERRESERVED</code>; such numbers are reserved for
@@ -39176,47 +38324,45 @@
 number).  You shouldn't duplicate a port number except in special
 circumstances where a higher-level protocol requires it.  Normally,
 the system won't let you do it; <code>bind</code> normally insists on
 distinct port numbers.  To reuse a port number, you must set the
-socket option <code>SO_REUSEADDR</code>.  See <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+socket option <code>SO_REUSEADDR</code>.  See <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <p>These macros are defined in the header file <code>netinet/in.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>IPPORT_RESERVED</b><i>
-</i></td>
+<td align="left"><code>int <b>IPPORT_RESERVED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Port numbers less than <code>IPPORT_RESERVED</code> are reserved for
 superuser use. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>IPPORT_USERRESERVED</b><i>
-</i></td>
+<td align="left"><code>int <b>IPPORT_USERRESERVED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Port numbers greater than or equal to <code>IPPORT_USERRESERVED</code> are
 reserved for explicit use; they will never be allocated automatically. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Services%20Database">Services Database</a>,
-Next:<a rel=next accesskey=n href="#Byte%20Order">Byte Order</a>,
+Node:<a name="Services Database">Services Database</a>,
+Next:<a rel=next accesskey=n href="#Byte Order">Byte Order</a>,
 Previous:<a rel=previous accesskey=p href="#Ports">Ports</a>,
-Up:<a rel=up accesskey=u href="#Internet%20Namespace">Internet Namespace</a>
+Up:<a rel=up accesskey=u href="#Internet Namespace">Internet Namespace</a>
 <br>
 
 <h4>The Services Database</h4>
 
@@ -39225,16 +38371,15 @@
 You can use these utilities, declared in <code>netdb.h</code>, to access
 the services database.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct servent</b><i>
-</i></td>
+<td align="left"><code><b>struct servent</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type holds information about entries from the services database. 
 It has the following members:
 
@@ -39247,13 +38392,13 @@
 strings.  A null pointer terminates the array.
 
 <br><dt><code>int s_port</code>
 <dd>This is the port number for the service.  Port numbers are given in
-network byte order; see <a href="#Byte%20Order">Byte Order</a>.
+network byte order; see <a href="#Byte Order">Byte Order</a>.
 
 <br><dt><code>char *s_proto</code>
 <dd>This is the name of the protocol to use with this service. 
-See <a href="#Protocols%20Database">Protocols Database</a>. 
+See <a href="#Protocols Database">Protocols Database</a>. 
 </dl>
 </td></tr>
 </table>
 
@@ -39262,16 +38407,15 @@
 is returned in a statically-allocated structure; you must copy the
 information if you need to save it across calls.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct servent * <b>getservbyname</b><i> (const char *<var>name</var>, const char *<var>proto</var>)
-</i></td>
+<td align="left"><code>struct servent * <b>getservbyname</b><i> (const char *<var>name</var>, const char *<var>proto</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getservbyname</code> function returns information about the
 service named <var>name</var> using protocol <var>proto</var>.  If it can't find
 such a service, it returns a null pointer.
@@ -39281,16 +38425,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct servent * <b>getservbyport</b><i> (int <var>port</var>, const char *<var>proto</var>)
-</i></td>
+<td align="left"><code>struct servent * <b>getservbyport</b><i> (int <var>port</var>, const char *<var>proto</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getservbyport</code> function returns information about the
 service at port <var>port</var> using protocol <var>proto</var>.  If it can't
 find such a service, it returns a null pointer. 
@@ -39301,16 +38444,15 @@
 <code>getservent</code> and <code>endservent</code>.  Be careful when using these
 functions because they are not reentrant.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setservent</b><i> (int <var>stayopen</var>)
-</i></td>
+<td align="left"><code>void <b>setservent</b><i> (int <var>stayopen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens the services database to begin scanning it.
 
 <p>If the <var>stayopen</var> argument is nonzero, this sets a flag so that
@@ -39321,41 +38463,39 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct servent * <b>getservent</b><i> (void)
-</i></td>
+<td align="left"><code>struct servent * <b>getservent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next entry in the services database.  If
 there are no more entries, it returns a null pointer. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endservent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endservent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the services database. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Byte%20Order">Byte Order</a>,
-Next:<a rel=next accesskey=n href="#Inet%20Example">Inet Example</a>,
-Previous:<a rel=previous accesskey=p href="#Services%20Database">Services Database</a>,
-Up:<a rel=up accesskey=u href="#Internet%20Namespace">Internet Namespace</a>
+Node:<a name="Byte Order">Byte Order</a>,
+Next:<a rel=next accesskey=n href="#Inet Example">Inet Example</a>,
+Previous:<a rel=previous accesskey=p href="#Services Database">Services Database</a>,
+Up:<a rel=up accesskey=u href="#Internet Namespace">Internet Namespace</a>
 <br>
 
 <h4>Byte Order Conversion</h4>
 
@@ -39389,46 +38529,43 @@
 to <code>uint32_t</code>.)  These functions are declared in
 <code>netinet/in.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint16_t <b>htons</b><i> (uint16_t <var>hostshort</var>)
-</i></td>
+<td align="left"><code>uint16_t <b>htons</b><i> (uint16_t <var>hostshort</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts the <code>uint16_t</code> integer <var>hostshort</var> from
 host byte order to network byte order. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint16_t <b>ntohs</b><i> (uint16_t <var>netshort</var>)
-</i></td>
+<td align="left"><code>uint16_t <b>ntohs</b><i> (uint16_t <var>netshort</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts the <code>uint16_t</code> integer <var>netshort</var> from
 network byte order to host byte order. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>htonl</b><i> (uint32_t <var>hostlong</var>)
-</i></td>
+<td align="left"><code>uint32_t <b>htonl</b><i> (uint32_t <var>hostlong</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts the <code>uint32_t</code> integer <var>hostlong</var> from
 host byte order to network byte order.
 
@@ -39436,16 +38573,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uint32_t <b>ntohl</b><i> (uint32_t <var>netlong</var>)
-</i></td>
+<td align="left"><code>uint32_t <b>ntohl</b><i> (uint32_t <var>netlong</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function converts the <code>uint32_t</code> integer <var>netlong</var> from
 network byte order to host byte order.
 
@@ -39453,12 +38589,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Protocols%20Database">Protocols Database</a>,
+Node:<a name="Protocols Database">Protocols Database</a>,
 Next:<a rel=next accesskey=n href="#Ports">Ports</a>,
-Previous:<a rel=previous accesskey=p href="#Host%20Addresses">Host Addresses</a>,
-Up:<a rel=up accesskey=u href="#Internet%20Namespace">Internet Namespace</a>
+Previous:<a rel=previous accesskey=p href="#Host Addresses">Host Addresses</a>,
+Up:<a rel=up accesskey=u href="#Internet Namespace">Internet Namespace</a>
 <br>
 
 <h4>Protocols Database</h4>
 
@@ -39485,16 +38621,15 @@
 <p>Here are detailed descriptions of the utilities for accessing the
 protocols database.  These are declared in <code>netdb.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct protoent</b><i>
-</i></td>
+<td align="left"><code><b>struct protoent</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used to represent entries in the network protocols
 database.  It has the following members:
 
@@ -39518,32 +38653,30 @@
 returned in a statically-allocated structure; you must copy the
 information if you need to save it across calls.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct protoent * <b>getprotobyname</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>struct protoent * <b>getprotobyname</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getprotobyname</code> function returns information about the
 network protocol named <var>name</var>.  If there is no such protocol, it
 returns a null pointer. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct protoent * <b>getprotobynumber</b><i> (int <var>protocol</var>)
-</i></td>
+<td align="left"><code>struct protoent * <b>getprotobynumber</b><i> (int <var>protocol</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getprotobynumber</code> function returns information about the
 network protocol with number <var>protocol</var>.  If there is no such
 protocol, it returns a null pointer. 
@@ -39554,16 +38687,15 @@
 using <code>setprotoent</code>, <code>getprotoent</code> and <code>endprotoent</code>. 
 Be careful when using these functions because they are not reentrant.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setprotoent</b><i> (int <var>stayopen</var>)
-</i></td>
+<td align="left"><code>void <b>setprotoent</b><i> (int <var>stayopen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens the protocols database to begin scanning it.
 
 <p>If the <var>stayopen</var> argument is nonzero, this sets a flag so that
@@ -39574,40 +38706,38 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct protoent * <b>getprotoent</b><i> (void)
-</i></td>
+<td align="left"><code>struct protoent * <b>getprotoent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next entry in the protocols database.  It
 returns a null pointer if there are no more entries. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endprotoent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endprotoent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the protocols database. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Inet%20Example">Inet Example</a>,
-Previous:<a rel=previous accesskey=p href="#Byte%20Order">Byte Order</a>,
-Up:<a rel=up accesskey=u href="#Internet%20Namespace">Internet Namespace</a>
+Node:<a name="Inet Example">Inet Example</a>,
+Previous:<a rel=previous accesskey=p href="#Byte Order">Byte Order</a>,
+Up:<a rel=up accesskey=u href="#Internet Namespace">Internet Namespace</a>
 <br>
 
 <h4>Internet Socket Example</h4>
 
@@ -39682,11 +38812,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Misc%20Namespaces">Misc Namespaces</a>,
-Next:<a rel=next accesskey=n href="#Open%2fClose%20Sockets">Open/Close Sockets</a>,
-Previous:<a rel=previous accesskey=p href="#Internet%20Namespace">Internet Namespace</a>,
+Node:<a name="Misc Namespaces">Misc Namespaces</a>,
+Next:<a rel=next accesskey=n href="#Open%2fClose Sockets">Open/Close Sockets</a>,
+Previous:<a rel=previous accesskey=p href="#Internet Namespace">Internet Namespace</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Other Namespaces</h3>
@@ -39703,11 +38833,11 @@
 occasionally-used local area routing protocol, see the GNU Hurd Manual
 (to appear in the future).
 
 <p><hr>
-Node:<a name="Open%2fClose%20Sockets">Open/Close Sockets</a>,
+Node:<a name="Open%2fClose Sockets">Open/Close Sockets</a>,
 Next:<a rel=next accesskey=n href="#Connections">Connections</a>,
-Previous:<a rel=previous accesskey=p href="#Misc%20Namespaces">Misc Namespaces</a>,
+Previous:<a rel=previous accesskey=p href="#Misc Namespaces">Misc Namespaces</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Opening and Closing Sockets</h3>
@@ -39716,40 +38846,39 @@
 closing sockets.  The same functions work for all namespaces and
 connection styles.
 
 <ul>
-<li><a accesskey=1 href="#Creating%20a%20Socket">Creating a Socket</a>:            How to open a socket. 
-<li><a accesskey=2 href="#Closing%20a%20Socket">Closing a Socket</a>:             How to close a socket. 
-<li><a accesskey=3 href="#Socket%20Pairs">Socket Pairs</a>:                 These are created like pipes. 
+<li><a accesskey=1 href="#Creating a Socket">Creating a Socket</a>:            How to open a socket. 
+<li><a accesskey=2 href="#Closing a Socket">Closing a Socket</a>:             How to close a socket. 
+<li><a accesskey=3 href="#Socket Pairs">Socket Pairs</a>:                 These are created like pipes. 
 </ul>
 
 <p><hr>
-Node:<a name="Creating%20a%20Socket">Creating a Socket</a>,
-Next:<a rel=next accesskey=n href="#Closing%20a%20Socket">Closing a Socket</a>,
-Up:<a rel=up accesskey=u href="#Open%2fClose%20Sockets">Open/Close Sockets</a>
+Node:<a name="Creating a Socket">Creating a Socket</a>,
+Next:<a rel=next accesskey=n href="#Closing a Socket">Closing a Socket</a>,
+Up:<a rel=up accesskey=u href="#Open%2fClose Sockets">Open/Close Sockets</a>
 <br>
 
 <h4>Creating a Socket</h4>
 
 <p>The primitive for creating a socket is the <code>socket</code> function,
 declared in <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>socket</b><i> (int <var>namespace</var>, int <var>style</var>, int <var>protocol</var>)
-</i></td>
+<td align="left"><code>int <b>socket</b><i> (int <var>namespace</var>, int <var>style</var>, int <var>protocol</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function creates a socket and specifies communication style
 <var>style</var>, which should be one of the socket styles listed in
-<a href="#Communication%20Styles">Communication Styles</a>.  The <var>namespace</var> argument specifies
-the namespace; it must be <code>PF_LOCAL</code> (see <a href="#Local%20Namespace">Local Namespace</a>) or
-<code>PF_INET</code> (see <a href="#Internet%20Namespace">Internet Namespace</a>).  <var>protocol</var>
-designates the specific protocol (see <a href="#Socket%20Concepts">Socket Concepts</a>); zero is
+<a href="#Communication Styles">Communication Styles</a>.  The <var>namespace</var> argument specifies
+the namespace; it must be <code>PF_LOCAL</code> (see <a href="#Local Namespace">Local Namespace</a>) or
+<code>PF_INET</code> (see <a href="#Internet Namespace">Internet Namespace</a>).  <var>protocol</var>
+designates the specific protocol (see <a href="#Socket Concepts">Socket Concepts</a>); zero is
 usually right for <var>protocol</var>.
 
 <p>The return value from <code>socket</code> is the file descriptor for the new
 socket, or <code>-1</code> in case of error.  The following <code>errno</code> error
@@ -39780,39 +38909,38 @@
 </td></tr>
 </table>
 
 <p>For examples of how to call the <code>socket</code> function,
-see <a href="#Local%20Socket%20Example">Local Socket Example</a>, or <a href="#Inet%20Example">Inet Example</a>.
+see <a href="#Local Socket Example">Local Socket Example</a>, or <a href="#Inet Example">Inet Example</a>.
 
 <p><hr>
-Node:<a name="Closing%20a%20Socket">Closing a Socket</a>,
-Next:<a rel=next accesskey=n href="#Socket%20Pairs">Socket Pairs</a>,
-Previous:<a rel=previous accesskey=p href="#Creating%20a%20Socket">Creating a Socket</a>,
-Up:<a rel=up accesskey=u href="#Open%2fClose%20Sockets">Open/Close Sockets</a>
+Node:<a name="Closing a Socket">Closing a Socket</a>,
+Next:<a rel=next accesskey=n href="#Socket Pairs">Socket Pairs</a>,
+Previous:<a rel=previous accesskey=p href="#Creating a Socket">Creating a Socket</a>,
+Up:<a rel=up accesskey=u href="#Open%2fClose Sockets">Open/Close Sockets</a>
 <br>
 
 <h4>Closing a Socket</h4>
 
 <p>When you have finished using a socket, you can simply close its
-file descriptor with <code>close</code>; see <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>. 
+file descriptor with <code>close</code>; see <a href="#Opening and Closing Files">Opening and Closing Files</a>. 
 If there is still data waiting to be transmitted over the connection,
 normally <code>close</code> tries to complete this transmission.  You
 can control this behavior using the <code>SO_LINGER</code> socket option to
-specify a timeout period; see <a href="#Socket%20Options">Socket Options</a>.
+specify a timeout period; see <a href="#Socket Options">Socket Options</a>.
 
 <p>You can also shut down only reception or transmission on a
 connection by calling <code>shutdown</code>, which is declared in
 <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>shutdown</b><i> (int <var>socket</var>, int <var>how</var>)
-</i></td>
+<td align="left"><code>int <b>shutdown</b><i> (int <var>socket</var>, int <var>how</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>shutdown</code> function shuts down the connection of socket
 <var>socket</var>.  The argument <var>how</var> specifies what action to
 perform:
@@ -39847,11 +38975,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Socket%20Pairs">Socket Pairs</a>,
-Previous:<a rel=previous accesskey=p href="#Closing%20a%20Socket">Closing a Socket</a>,
-Up:<a rel=up accesskey=u href="#Open%2fClose%20Sockets">Open/Close Sockets</a>
+Node:<a name="Socket Pairs">Socket Pairs</a>,
+Previous:<a rel=previous accesskey=p href="#Closing a Socket">Closing a Socket</a>,
+Up:<a rel=up accesskey=u href="#Open%2fClose Sockets">Open/Close Sockets</a>
 <br>
 
 <h4>Socket Pairs</h4>
 
@@ -39859,30 +38987,29 @@
 sockets.  It is very similar to a pipe and is used in much the same
 way.  Socket pairs are created with the <code>socketpair</code> function,
 declared in <code>sys/socket.h</code>.  A socket pair is much like a pipe; the
 main difference is that the socket pair is bidirectional, whereas the
-pipe has one input-only end and one output-only end (see <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>).
+pipe has one input-only end and one output-only end (see <a href="#Pipes and FIFOs">Pipes and FIFOs</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>socketpair</b><i> (int <var>namespace</var>, int <var>style</var>, int <var>protocol</var>, int <var>filedes</var><tt>[2]</tt>)
-</i></td>
+<td align="left"><code>int <b>socketpair</b><i> (int <var>namespace</var>, int <var>style</var>, int <var>protocol</var>, int <var>filedes</var><tt>[2]</tt>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function creates a socket pair, returning the file descriptors in
 <code><var>filedes</var>[0]</code> and <code><var>filedes</var>[1]</code>.  The socket pair
 is a full-duplex communications channel, so that both reading and writing
 may be performed at either end.
 
 <p>The <var>namespace</var>, <var>style</var> and <var>protocol</var> arguments are
 interpreted as for the <code>socket</code> function.  <var>style</var> should be
-one of the communication styles listed in <a href="#Communication%20Styles">Communication Styles</a>. 
+one of the communication styles listed in <a href="#Communication Styles">Communication Styles</a>. 
 The <var>namespace</var> argument specifies the namespace, which must be
-<code>AF_LOCAL</code> (see <a href="#Local%20Namespace">Local Namespace</a>); <var>protocol</var> specifies the
+<code>AF_LOCAL</code> (see <a href="#Local Namespace">Local Namespace</a>); <var>protocol</var> specifies the
 communications protocol, but zero is the only meaningful value.
 
 <p>If <var>style</var> specifies a connectionless communication style, then
 the two sockets you get are not <em>connected</em>, strictly speaking,
@@ -39911,9 +39038,9 @@
 
 <p><hr>
 Node:<a name="Connections">Connections</a>,
 Next:<a rel=next accesskey=n href="#Datagrams">Datagrams</a>,
-Previous:<a rel=previous accesskey=p href="#Open%2fClose%20Sockets">Open/Close Sockets</a>,
+Previous:<a rel=previous accesskey=p href="#Open%2fClose Sockets">Open/Close Sockets</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Using Sockets with Connections</h3>
@@ -39926,16 +39053,16 @@
 
 <ul>
 <li><a accesskey=1 href="#Connecting">Connecting</a>:     	     What the client program must do. 
 <li><a accesskey=2 href="#Listening">Listening</a>: 		     How a server program waits for requests. 
-<li><a accesskey=3 href="#Accepting%20Connections">Accepting Connections</a>:     What the server does when it gets a request. 
-<li><a accesskey=4 href="#Who%20is%20Connected">Who is Connected</a>: 	     Getting the address of the
+<li><a accesskey=3 href="#Accepting Connections">Accepting Connections</a>:     What the server does when it gets a request. 
+<li><a accesskey=4 href="#Who is Connected">Who is Connected</a>: 	     Getting the address of the
 				other side of a connection. 
-<li><a accesskey=5 href="#Transferring%20Data">Transferring Data</a>:         How to send and receive data. 
-<li><a accesskey=6 href="#Byte%20Stream%20Example">Byte Stream Example</a>: 	     An example program: a client for communicating
+<li><a accesskey=5 href="#Transferring Data">Transferring Data</a>:         How to send and receive data. 
+<li><a accesskey=6 href="#Byte Stream Example">Byte Stream Example</a>: 	     An example program: a client for communicating
 			      over a byte stream socket in the Internet namespace. 
-<li><a accesskey=7 href="#Server%20Example">Server Example</a>: 	     A corresponding server program. 
-<li><a accesskey=8 href="#Out-of-Band%20Data">Out-of-Band Data</a>:          This is an advanced feature. 
+<li><a accesskey=7 href="#Server Example">Server Example</a>: 	     A corresponding server program. 
+<li><a accesskey=8 href="#Out-of-Band Data">Out-of-Band Data</a>:          This is an advanced feature. 
 </ul>
 
 <p><hr>
 Node:<a name="Connecting">Connecting</a>,
@@ -39950,28 +39077,27 @@
 program must do with the <code>connect</code> function, which is declared in
 <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>connect</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>connect</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>connect</code> function initiates a connection from the socket
 with file descriptor <var>socket</var> to the socket whose address is
 specified by the <var>addr</var> and <var>length</var> arguments.  (This socket
 is typically on another machine, and it must be already set up as a
-server.)  See <a href="#Socket%20Addresses">Socket Addresses</a>, for information about how these
+server.)  See <a href="#Socket Addresses">Socket Addresses</a>, for information about how these
 arguments are interpreted.
 
 <p>Normally, <code>connect</code> waits until the server responds to the request
 before it returns.  You can set nonblocking mode on the socket
 <var>socket</var> to make <code>connect</code> return immediately without waiting
-for the response.  See <a href="#File%20Status%20Flags">File Status Flags</a>, for information about
+for the response.  See <a href="#File Status Flags">File Status Flags</a>, for information about
 nonblocking mode.
 
 <p>The normal return value from <code>connect</code> is <code>0</code>.  If an error
 occurs, <code>connect</code> returns <code>-1</code>.  The following <code>errno</code>
@@ -40007,9 +39133,9 @@
 
 <br><dt><code>EINPROGRESS</code>
 <dd>The socket <var>socket</var> is non-blocking and the connection could not be
 established immediately.  You can determine when the connection is
-completely established with <code>select</code>; see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>. 
+completely established with <code>select</code>; see <a href="#Waiting for I%2fO">Waiting for I/O</a>. 
 Another <code>connect</code> call on the same socket, before the connection is
 completely established, will fail with <code>EALREADY</code>.
 
 <br><dt><code>EALREADY</code>
@@ -40025,9 +39151,9 @@
 </table>
 
 <p><hr>
 Node:<a name="Listening">Listening</a>,
-Next:<a rel=next accesskey=n href="#Accepting%20Connections">Accepting Connections</a>,
+Next:<a rel=next accesskey=n href="#Accepting Connections">Accepting Connections</a>,
 Previous:<a rel=previous accesskey=p href="#Connecting">Connecting</a>,
 Up:<a rel=up accesskey=u href="#Connections">Connections</a>
 <br>
 
@@ -40035,17 +39161,17 @@
 
 <p>Now let us consider what the server process must do to accept
 connections on a socket.  First it must use the <code>listen</code> function
 to enable connection requests on the socket, and then accept each
-incoming connection with a call to <code>accept</code> (see <a href="#Accepting%20Connections">Accepting Connections</a>).  Once connection requests are enabled on a server socket,
+incoming connection with a call to <code>accept</code> (see <a href="#Accepting Connections">Accepting Connections</a>).  Once connection requests are enabled on a server socket,
 the <code>select</code> function reports when the socket has a connection
-ready to be accepted (see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>).
+ready to be accepted (see <a href="#Waiting for I%2fO">Waiting for I/O</a>).
 
 <p>The <code>listen</code> function is not allowed for sockets using
 connectionless communication styles.
 
 <p>You can write a network server that does not even start running until a
-connection to it is requested.  See <a href="#Inetd%20Servers">Inetd Servers</a>.
+connection to it is requested.  See <a href="#Inetd Servers">Inetd Servers</a>.
 
 <p>In the Internet namespace, there are no special protection mechanisms
 for controlling access to a port; any process on any machine
 can make a connection to your server.  If you want to restrict access to
@@ -40056,16 +39182,15 @@
 <p>In the local namespace, the ordinary file protection bits control who has
 access to connect to the socket.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>listen</b><i> (int <var>socket</var>, unsigned int <var>n</var>)
-</i></td>
+<td align="left"><code>int <b>listen</b><i> (int <var>socket</var>, unsigned int <var>n</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>listen</code> function enables the socket <var>socket</var> to accept
 connections, thus making it a server socket.
 
@@ -40091,10 +39216,10 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Accepting%20Connections">Accepting Connections</a>,
-Next:<a rel=next accesskey=n href="#Who%20is%20Connected">Who is Connected</a>,
+Node:<a name="Accepting Connections">Accepting Connections</a>,
+Next:<a rel=next accesskey=n href="#Who is Connected">Who is Connected</a>,
 Previous:<a rel=previous accesskey=p href="#Listening">Listening</a>,
 Up:<a rel=up accesskey=u href="#Connections">Connections</a>
 <br>
 
@@ -40120,29 +39245,28 @@
 system may also impose its own internal limit on the length of this
 queue.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>accept</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length_ptr</var>)
-</i></td>
+<td align="left"><code>int <b>accept</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length_ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to accept a connection request on the server
 socket <var>socket</var>.
 
 <p>The <code>accept</code> function waits if there are no connections pending,
 unless the socket <var>socket</var> has nonblocking mode set.  (You can use
 <code>select</code> to wait for a pending connection, with a nonblocking
-socket.)  See <a href="#File%20Status%20Flags">File Status Flags</a>, for information about nonblocking
+socket.)  See <a href="#File Status Flags">File Status Flags</a>, for information about nonblocking
 mode.
 
 <p>The <var>addr</var> and <var>length-ptr</var> arguments are used to return
 information about the name of the client socket that initiated the
-connection.  See <a href="#Socket%20Addresses">Socket Addresses</a>, for information about the format
+connection.  See <a href="#Socket Addresses">Socket Addresses</a>, for information about the format
 of the information.
 
 <p>Accepting a connection does not make <var>socket</var> part of the
 connection.  Instead, it creates a new socket which becomes
@@ -40182,32 +39306,31 @@
 <p>The <code>accept</code> function is not allowed for sockets using
 connectionless communication styles.
 
 <p><hr>
-Node:<a name="Who%20is%20Connected">Who is Connected</a>,
-Next:<a rel=next accesskey=n href="#Transferring%20Data">Transferring Data</a>,
-Previous:<a rel=previous accesskey=p href="#Accepting%20Connections">Accepting Connections</a>,
+Node:<a name="Who is Connected">Who is Connected</a>,
+Next:<a rel=next accesskey=n href="#Transferring Data">Transferring Data</a>,
+Previous:<a rel=previous accesskey=p href="#Accepting Connections">Accepting Connections</a>,
 Up:<a rel=up accesskey=u href="#Connections">Connections</a>
 <br>
 
 <h4>Who is Connected to Me?</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpeername</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>getpeername</b><i> (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getpeername</code> function returns the address of the socket that
 <var>socket</var> is connected to; it stores the address in the memory space
 specified by <var>addr</var> and <var>length-ptr</var>.  It stores the length of
 the address in <code>*<var>length-ptr</var></code>.
 
-<p>See <a href="#Socket%20Addresses">Socket Addresses</a>, for information about the format of the
+<p>See <a href="#Socket Addresses">Socket Addresses</a>, for information about the format of the
 address.  In some operating systems, <code>getpeername</code> works only for
 sockets in the Internet domain.
 
 <p>The return value is <code>0</code> on success and <code>-1</code> on error.  The
@@ -40229,18 +39352,18 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Transferring%20Data">Transferring Data</a>,
-Next:<a rel=next accesskey=n href="#Byte%20Stream%20Example">Byte Stream Example</a>,
-Previous:<a rel=previous accesskey=p href="#Who%20is%20Connected">Who is Connected</a>,
+Node:<a name="Transferring Data">Transferring Data</a>,
+Next:<a rel=next accesskey=n href="#Byte Stream Example">Byte Stream Example</a>,
+Previous:<a rel=previous accesskey=p href="#Who is Connected">Who is Connected</a>,
 Up:<a rel=up accesskey=u href="#Connections">Connections</a>
 <br>
 
 <h4>Transferring Data</h4>
 
 <p>Once a socket has been connected to a peer, you can use the ordinary
-<code>read</code> and <code>write</code> operations (see <a href="#I%2fO%20Primitives">I/O Primitives</a>) to
+<code>read</code> and <code>write</code> operations (see <a href="#I%2fO Primitives">I/O Primitives</a>) to
 transfer data.  A socket is a two-way communications channel, so read
 and write operations can be performed at either end.
 
 <p>There are also some I/O modes that are specific to socket operations. 
@@ -40253,45 +39376,44 @@
 <code>MSG_PEEK</code> flag to peek at input, or the <code>MSG_DONTROUTE</code> flag
 to control inclusion of routing information on output.
 
 <ul>
-<li><a accesskey=1 href="#Sending%20Data">Sending Data</a>: 		Sending data with <code>send</code>. 
-<li><a accesskey=2 href="#Receiving%20Data">Receiving Data</a>: 		Reading data with <code>recv</code>. 
-<li><a accesskey=3 href="#Socket%20Data%20Options">Socket Data Options</a>: 		Using <code>send</code> and <code>recv</code>. 
+<li><a accesskey=1 href="#Sending Data">Sending Data</a>: 		Sending data with <code>send</code>. 
+<li><a accesskey=2 href="#Receiving Data">Receiving Data</a>: 		Reading data with <code>recv</code>. 
+<li><a accesskey=3 href="#Socket Data Options">Socket Data Options</a>: 		Using <code>send</code> and <code>recv</code>. 
 </ul>
 
 <p><hr>
-Node:<a name="Sending%20Data">Sending Data</a>,
-Next:<a rel=next accesskey=n href="#Receiving%20Data">Receiving Data</a>,
-Up:<a rel=up accesskey=u href="#Transferring%20Data">Transferring Data</a>
+Node:<a name="Sending Data">Sending Data</a>,
+Next:<a rel=next accesskey=n href="#Receiving Data">Receiving Data</a>,
+Up:<a rel=up accesskey=u href="#Transferring Data">Transferring Data</a>
 <br>
 
 <h5>Sending Data</h5>
 
 <p>The <code>send</code> function is declared in the header file
 <code>sys/socket.h</code>.  If your <var>flags</var> argument is zero, you can just
-as well use <code>write</code> instead of <code>send</code>; see <a href="#I%2fO%20Primitives">I/O Primitives</a>.  If the socket was connected but the connection has broken,
+as well use <code>write</code> instead of <code>send</code>; see <a href="#I%2fO Primitives">I/O Primitives</a>.  If the socket was connected but the connection has broken,
 you get a <code>SIGPIPE</code> signal for any use of <code>send</code> or
-<code>write</code> (see <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>).
+<code>write</code> (see <a href="#Miscellaneous Signals">Miscellaneous Signals</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>send</b><i> (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>)
-</i></td>
+<td align="left"><code>int <b>send</b><i> (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>send</code> function is like <code>write</code>, but with the additional
 flags <var>flags</var>.  The possible values of <var>flags</var> are described
-in <a href="#Socket%20Data%20Options">Socket Data Options</a>.
+in <a href="#Socket Data Options">Socket Data Options</a>.
 
 <p>This function returns the number of bytes transmitted, or <code>-1</code> on
 failure.  If the socket is nonblocking, then <code>send</code> (like
 <code>write</code>) can return after sending just part of the data. 
-See <a href="#File%20Status%20Flags">File Status Flags</a>, for information about nonblocking mode.
+See <a href="#File Status Flags">File Status Flags</a>, for information about nonblocking mode.
 
 <p>Note, however, that a successful return value merely indicates that
 the message has been sent without error, not necessarily that it has
 been received without error.
@@ -40303,9 +39425,9 @@
 <dd>The <var>socket</var> argument is not a valid file descriptor.
 
 <br><dt><code>EINTR</code>
 <dd>The operation was interrupted by a signal before any data was sent. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>ENOTSOCK</code>
 <dd>The descriptor <var>socket</var> is not a socket.
 
@@ -40338,36 +39460,35 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Receiving%20Data">Receiving Data</a>,
-Next:<a rel=next accesskey=n href="#Socket%20Data%20Options">Socket Data Options</a>,
-Previous:<a rel=previous accesskey=p href="#Sending%20Data">Sending Data</a>,
-Up:<a rel=up accesskey=u href="#Transferring%20Data">Transferring Data</a>
+Node:<a name="Receiving Data">Receiving Data</a>,
+Next:<a rel=next accesskey=n href="#Socket Data Options">Socket Data Options</a>,
+Previous:<a rel=previous accesskey=p href="#Sending Data">Sending Data</a>,
+Up:<a rel=up accesskey=u href="#Transferring Data">Transferring Data</a>
 <br>
 
 <h5>Receiving Data</h5>
 
 <p>The <code>recv</code> function is declared in the header file
 <code>sys/socket.h</code>.  If your <var>flags</var> argument is zero, you can
-just as well use <code>read</code> instead of <code>recv</code>; see <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+just as well use <code>read</code> instead of <code>recv</code>; see <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>recv</b><i> (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>)
-</i></td>
+<td align="left"><code>int <b>recv</b><i> (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>recv</code> function is like <code>read</code>, but with the additional
 flags <var>flags</var>.  The possible values of <var>flags</var> are described
-in <a href="#Socket%20Data%20Options">Socket Data Options</a>.
+in <a href="#Socket Data Options">Socket Data Options</a>.
 
 <p>If nonblocking mode is set for <var>socket</var>, and no data are available to
-be read, <code>recv</code> fails immediately rather than waiting.  See <a href="#File%20Status%20Flags">File Status Flags</a>, for information about nonblocking mode.
+be read, <code>recv</code> fails immediately rather than waiting.  See <a href="#File Status Flags">File Status Flags</a>, for information about nonblocking mode.
 
 <p>This function returns the number of bytes received, or <code>-1</code> on failure. 
 The following <code>errno</code> error conditions are defined for this function:
 
@@ -40384,9 +39505,9 @@
 available to be read.)
 
 <br><dt><code>EINTR</code>
 <dd>The operation was interrupted by a signal before any data was read. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>ENOTCONN</code>
 <dd>You never connected this socket. 
 </dl>
@@ -40398,11 +39519,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Socket%20Data%20Options">Socket Data Options</a>,
-Previous:<a rel=previous accesskey=p href="#Receiving%20Data">Receiving Data</a>,
-Up:<a rel=up accesskey=u href="#Transferring%20Data">Transferring Data</a>
+Node:<a name="Socket Data Options">Socket Data Options</a>,
+Previous:<a rel=previous accesskey=p href="#Receiving Data">Receiving Data</a>,
+Up:<a rel=up accesskey=u href="#Transferring Data">Transferring Data</a>
 <br>
 
 <h5>Socket Data Options</h5>
 
@@ -40411,57 +39532,54 @@
 to obtain a value for this argument.  All are defined in the header
 file <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MSG_OOB</b><i>
-</i></td>
+<td align="left"><code>int <b>MSG_OOB</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-Send or receive out-of-band data.  See <a href="#Out-of-Band%20Data">Out-of-Band Data</a>. 
+Send or receive out-of-band data.  See <a href="#Out-of-Band Data">Out-of-Band Data</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MSG_PEEK</b><i>
-</i></td>
+<td align="left"><code>int <b>MSG_PEEK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Look at the data but don't remove it from the input queue.  This is
 only meaningful with input functions such as <code>recv</code>, not with
 <code>send</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MSG_DONTROUTE</b><i>
-</i></td>
+<td align="left"><code>int <b>MSG_DONTROUTE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Don't include routing information in the message.  This is only
 meaningful with output operations, and is usually only of interest for
 diagnostic or routing programs.  We don't try to explain it here. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Byte%20Stream%20Example">Byte Stream Example</a>,
-Next:<a rel=next accesskey=n href="#Server%20Example">Server Example</a>,
-Previous:<a rel=previous accesskey=p href="#Transferring%20Data">Transferring Data</a>,
+Node:<a name="Byte Stream Example">Byte Stream Example</a>,
+Next:<a rel=next accesskey=n href="#Server Example">Server Example</a>,
+Previous:<a rel=previous accesskey=p href="#Transferring Data">Transferring Data</a>,
 Up:<a rel=up accesskey=u href="#Connections">Connections</a>
 <br>
 
 <h4>Byte Stream Socket Example</h4>
@@ -40471,9 +39589,9 @@
 particularly interesting once it has connected to the server; it just
 sends a text string to the server and exits.
 
 <p>This program uses <code>init_sockaddr</code> to set up the socket address; see
-<a href="#Inet%20Example">Inet Example</a>.
+<a href="#Inet Example">Inet Example</a>.
 
 <br><pre>
 
 #include &lt;stdio.h&gt;
@@ -40537,11 +39655,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Server%20Example">Server Example</a>,
-Next:<a rel=next accesskey=n href="#Out-of-Band%20Data">Out-of-Band Data</a>,
-Previous:<a rel=previous accesskey=p href="#Byte%20Stream%20Example">Byte Stream Example</a>,
+Node:<a name="Server Example">Server Example</a>,
+Next:<a rel=next accesskey=n href="#Out-of-Band Data">Out-of-Band Data</a>,
+Previous:<a rel=previous accesskey=p href="#Byte Stream Example">Byte Stream Example</a>,
 Up:<a rel=up accesskey=u href="#Connections">Connections</a>
 <br>
 
 <h4>Byte Stream Connection Server Example</h4>
@@ -40549,9 +39667,9 @@
 <p>The server end is much more complicated.  Since we want to allow
 multiple clients to be connected to the server at the same time, it
 would be incorrect to wait for input from a single client by simply
 calling <code>read</code> or <code>recv</code>.  Instead, the right thing to do is
-to use <code>select</code> (see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>) to wait for input on
+to use <code>select</code> (see <a href="#Waiting for I%2fO">Waiting for I/O</a>) to wait for input on
 all of the open sockets.  This also allows the server to deal with
 additional connection requests.
 
 <p>This particular server doesn't do anything interesting once it has
@@ -40559,9 +39677,9 @@
 client when it detects an end-of-file condition (resulting from the
 client shutting down its end of the connection).
 
 <p>This program uses <code>make_socket</code> to set up the socket address; see
-<a href="#Inet%20Example">Inet Example</a>.
+<a href="#Inet Example">Inet Example</a>.
 
 <br><pre>
 
 #include &lt;stdio.h&gt;
@@ -40594,9 +39712,9 @@
     return -1;
   else
     {
       /* Data read. */
-      fprintf (stderr, "Server: got message: `%s'\n", buffer);
+      fprintf (stderr, "Server: got message: '%s'\n", buffer);
       return 0;
     }
 }
 
@@ -40669,10 +39787,10 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Out-of-Band%20Data">Out-of-Band Data</a>,
-Previous:<a rel=previous accesskey=p href="#Server%20Example">Server Example</a>,
+Node:<a name="Out-of-Band Data">Out-of-Band Data</a>,
+Previous:<a rel=previous accesskey=p href="#Server Example">Server Example</a>,
 Up:<a rel=up accesskey=u href="#Connections">Connections</a>
 <br>
 
 <h4>Out-of-Band Data</h4>
@@ -40680,26 +39798,26 @@
 <p>Streams with connections permit <dfn>out-of-band</dfn> data that is
 delivered with higher priority than ordinary data.  Typically the
 reason for sending out-of-band data is to send notice of an
 exceptional condition.  To send out-of-band data use
-<code>send</code>, specifying the flag <code>MSG_OOB</code> (see <a href="#Sending%20Data">Sending Data</a>).
+<code>send</code>, specifying the flag <code>MSG_OOB</code> (see <a href="#Sending Data">Sending Data</a>).
 
 <p>Out-of-band data are received with higher priority because the
 receiving process need not read it in sequence; to read the next
 available out-of-band data, use <code>recv</code> with the <code>MSG_OOB</code>
-flag (see <a href="#Receiving%20Data">Receiving Data</a>).  Ordinary read operations do not read
+flag (see <a href="#Receiving Data">Receiving Data</a>).  Ordinary read operations do not read
 out-of-band data; they read only ordinary data.
 
 <p>When a socket finds that out-of-band data are on their way, it sends a
 <code>SIGURG</code> signal to the owner process or process group of the
 socket.  You can specify the owner using the <code>F_SETOWN</code> command
-to the <code>fcntl</code> function; see <a href="#Interrupt%20Input">Interrupt Input</a>.  You must
-also establish a handler for this signal, as described in <a href="#Signal%20Handling">Signal Handling</a>, in order to take appropriate action such as reading the
+to the <code>fcntl</code> function; see <a href="#Interrupt Input">Interrupt Input</a>.  You must
+also establish a handler for this signal, as described in <a href="#Signal Handling">Signal Handling</a>, in order to take appropriate action such as reading the
 out-of-band data.
 
 <p>Alternatively, you can test for pending out-of-band data, or wait
 until there is out-of-band data, using the <code>select</code> function; it
-can wait for an exceptional condition on the socket.  See <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>, for more information about <code>select</code>.
+can wait for an exceptional condition on the socket.  See <a href="#Waiting for I%2fO">Waiting for I/O</a>, for more information about <code>select</code>.
 
 <p>Notification of out-of-band data (whether with <code>SIGURG</code> or with
 <code>select</code>) indicates that out-of-band data are on the way; the data
 may not actually arrive until later.  If you try to read the
@@ -40762,15 +39880,15 @@
   struct buffer *next;
 };
 
 /* Read the out-of-band data from SOCKET and return it
-   as a `struct buffer', which records the address of the data
+   as a 'struct buffer', which records the address of the data
    and its size.
 
    It may be necessary to read some ordinary data
    in order to make room for the out-of-band data.
    If so, the ordinary data are saved as a chain of buffers
-   found in the `next' field of the value.  */
+   found in the 'next' field of the value.  */
 
 struct buffer *
 read_oob (int socket)
 {
@@ -40858,18 +39976,18 @@
 <p>The <code>listen</code> and <code>accept</code> functions are not allowed for
 sockets using connectionless communication styles.
 
 <ul>
-<li><a accesskey=1 href="#Sending%20Datagrams">Sending Datagrams</a>:     Sending packets on a datagram socket. 
-<li><a accesskey=2 href="#Receiving%20Datagrams">Receiving Datagrams</a>:   Receiving packets on a datagram socket. 
-<li><a accesskey=3 href="#Datagram%20Example">Datagram Example</a>:      An example program: packets sent over a
+<li><a accesskey=1 href="#Sending Datagrams">Sending Datagrams</a>:     Sending packets on a datagram socket. 
+<li><a accesskey=2 href="#Receiving Datagrams">Receiving Datagrams</a>:   Receiving packets on a datagram socket. 
+<li><a accesskey=3 href="#Datagram Example">Datagram Example</a>:      An example program: packets sent over a
                            datagram socket in the local namespace. 
-<li><a accesskey=4 href="#Example%20Receiver">Example Receiver</a>: 	 Another program, that receives those packets. 
+<li><a accesskey=4 href="#Example Receiver">Example Receiver</a>: 	 Another program, that receives those packets. 
 </ul>
 
 <p><hr>
-Node:<a name="Sending%20Datagrams">Sending Datagrams</a>,
-Next:<a rel=next accesskey=n href="#Receiving%20Datagrams">Receiving Datagrams</a>,
+Node:<a name="Sending Datagrams">Sending Datagrams</a>,
+Next:<a rel=next accesskey=n href="#Receiving Datagrams">Receiving Datagrams</a>,
 Up:<a rel=up accesskey=u href="#Datagrams">Datagrams</a>
 <br>
 
 <h4>Sending Datagrams</h4>
@@ -40879,30 +39997,29 @@
 
 <p>You can call <code>connect</code> on a datagram socket, but this only
 specifies a default destination for further data transmission on the
 socket.  When a socket has a default destination you can use
-<code>send</code> (see <a href="#Sending%20Data">Sending Data</a>) or even <code>write</code> (see <a href="#I%2fO%20Primitives">I/O Primitives</a>) to send a packet there.  You can cancel the default
+<code>send</code> (see <a href="#Sending Data">Sending Data</a>) or even <code>write</code> (see <a href="#I%2fO Primitives">I/O Primitives</a>) to send a packet there.  You can cancel the default
 destination by calling <code>connect</code> using an address format of
 <code>AF_UNSPEC</code> in the <var>addr</var> argument.  See <a href="#Connecting">Connecting</a>, for
 more information about the <code>connect</code> function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sendto</b><i> (int <var>socket</var>, void *<var>buffer</var>. size_t <var>size</var>, int <var>flags</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>sendto</b><i> (int <var>socket</var>, void *<var>buffer</var>. size_t <var>size</var>, int <var>flags</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sendto</code> function transmits the data in the <var>buffer</var>
 through the socket <var>socket</var> to the destination address specified
 by the <var>addr</var> and <var>length</var> arguments.  The <var>size</var> argument
 specifies the number of bytes to be transmitted.
 
 <p>The <var>flags</var> are interpreted the same way as for <code>send</code>; see
-<a href="#Socket%20Data%20Options">Socket Data Options</a>.
+<a href="#Socket Data Options">Socket Data Options</a>.
 
 <p>The return value and error conditions are also the same as for
 <code>send</code>, but you cannot rely on the system to detect errors and
 report them; the most common error is that the packet is lost or there
@@ -40919,11 +40036,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Receiving%20Datagrams">Receiving Datagrams</a>,
-Next:<a rel=next accesskey=n href="#Datagram%20Example">Datagram Example</a>,
-Previous:<a rel=previous accesskey=p href="#Sending%20Datagrams">Sending Datagrams</a>,
+Node:<a name="Receiving Datagrams">Receiving Datagrams</a>,
+Next:<a rel=next accesskey=n href="#Datagram Example">Datagram Example</a>,
+Previous:<a rel=previous accesskey=p href="#Sending Datagrams">Sending Datagrams</a>,
 Up:<a rel=up accesskey=u href="#Datagrams">Datagrams</a>
 <br>
 
 <h4>Receiving Datagrams</h4>
@@ -40932,16 +40049,15 @@
 also tells you where it was sent from.  This function is declared in
 <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>recvfrom</b><i> (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>recvfrom</b><i> (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>recvfrom</code> function reads one packet from the socket
 <var>socket</var> into the buffer <var>buffer</var>.  The <var>size</var> argument
 specifies the maximum number of bytes to be read.
@@ -40951,15 +40067,15 @@
 There's no way to read the rest of the packet.  Thus, when you use a
 packet protocol, you must always know how long a packet to expect.
 
 <p>The <var>addr</var> and <var>length-ptr</var> arguments are used to return the
-address where the packet came from.  See <a href="#Socket%20Addresses">Socket Addresses</a>.  For a
+address where the packet came from.  See <a href="#Socket Addresses">Socket Addresses</a>.  For a
 socket in the local domain the address information won't be meaningful,
-since you can't read the address of such a socket (see <a href="#Local%20Namespace">Local Namespace</a>).  You can specify a null pointer as the <var>addr</var> argument
+since you can't read the address of such a socket (see <a href="#Local Namespace">Local Namespace</a>).  You can specify a null pointer as the <var>addr</var> argument
 if you are not interested in this information.
 
 <p>The <var>flags</var> are interpreted the same way as for <code>recv</code>
-(see <a href="#Socket%20Data%20Options">Socket Data Options</a>).  The return value and error conditions
+(see <a href="#Socket Data Options">Socket Data Options</a>).  The return value and error conditions
 are also the same as for <code>recv</code>.
 
 <p>This function is defined as a cancellation point in multi-threaded
 programs, so one has to be prepared for this and make sure that
@@ -40967,26 +40083,26 @@
 whatever) are freed even if the thread is canceled. 
 </td></tr>
 </table>
 
-<p>You can use plain <code>recv</code> (see <a href="#Receiving%20Data">Receiving Data</a>) instead of
+<p>You can use plain <code>recv</code> (see <a href="#Receiving Data">Receiving Data</a>) instead of
 <code>recvfrom</code> if you don't need to find out who sent the packet
 (either because you know where it should come from or because you
 treat all possible senders alike).  Even <code>read</code> can be used if
-you don't want to specify <var>flags</var> (see <a href="#I%2fO%20Primitives">I/O Primitives</a>).
+you don't want to specify <var>flags</var> (see <a href="#I%2fO Primitives">I/O Primitives</a>).
 
 <p><hr>
-Node:<a name="Datagram%20Example">Datagram Example</a>,
-Next:<a rel=next accesskey=n href="#Example%20Receiver">Example Receiver</a>,
-Previous:<a rel=previous accesskey=p href="#Receiving%20Datagrams">Receiving Datagrams</a>,
+Node:<a name="Datagram Example">Datagram Example</a>,
+Next:<a rel=next accesskey=n href="#Example Receiver">Example Receiver</a>,
+Previous:<a rel=previous accesskey=p href="#Receiving Datagrams">Receiving Datagrams</a>,
 Up:<a rel=up accesskey=u href="#Datagrams">Datagrams</a>
 <br>
 
 <h4>Datagram Socket Example</h4>
 
 <p>Here is a set of example programs that send messages over a datagram
 stream in the local namespace.  Both the client and server programs use
-the <code>make_named_socket</code> function that was presented in <a href="#Local%20Socket%20Example">Local Socket Example</a>, to create and name their sockets.
+the <code>make_named_socket</code> function that was presented in <a href="#Local Socket Example">Local Socket Example</a>, to create and name their sockets.
 
 <p>First, here is the server program.  It sits in a loop waiting for
 messages to arrive, bouncing each message back to the sender. 
 Obviously this isn't a particularly useful program, but it does show
@@ -41044,10 +40160,10 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Example%20Receiver">Example Receiver</a>,
-Previous:<a rel=previous accesskey=p href="#Datagram%20Example">Datagram Example</a>,
+Node:<a name="Example Receiver">Example Receiver</a>,
+Previous:<a rel=previous accesskey=p href="#Datagram Example">Datagram Example</a>,
 Up:<a rel=up accesskey=u href="#Datagrams">Datagrams</a>
 <br>
 
 <h4>Example of Reading Datagrams</h4>
@@ -41123,15 +40239,15 @@
 this example, the client program waits indefinitely if the message
 never reaches the server or if the server's response never comes
 back.  It's up to the user running the program to kill and restart
 it if desired.  A more automatic solution could be to use
-<code>select</code> (see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>) to establish a timeout period
+<code>select</code> (see <a href="#Waiting for I%2fO">Waiting for I/O</a>) to establish a timeout period
 for the reply, and in case of timeout either re-send the message or
 shut down the socket and exit.
 
 <p><hr>
 Node:<a name="Inetd">Inetd</a>,
-Next:<a rel=next accesskey=n href="#Socket%20Options">Socket Options</a>,
+Next:<a rel=next accesskey=n href="#Socket Options">Socket Options</a>,
 Previous:<a rel=previous accesskey=p href="#Datagrams">Datagrams</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
@@ -41149,15 +40265,15 @@
 child process to run the corresponding server program.  You specify the
 ports and their programs in the file <code>/etc/inetd.conf</code>.
 
 <ul>
-<li><a accesskey=1 href="#Inetd%20Servers">Inetd Servers</a>: 
-<li><a accesskey=2 href="#Configuring%20Inetd">Configuring Inetd</a>: 
+<li><a accesskey=1 href="#Inetd Servers">Inetd Servers</a>: 
+<li><a accesskey=2 href="#Configuring Inetd">Configuring Inetd</a>: 
 </ul>
 
 <p><hr>
-Node:<a name="Inetd%20Servers">Inetd Servers</a>,
-Next:<a rel=next accesskey=n href="#Configuring%20Inetd">Configuring Inetd</a>,
+Node:<a name="Inetd Servers">Inetd Servers</a>,
+Next:<a rel=next accesskey=n href="#Configuring Inetd">Configuring Inetd</a>,
 Up:<a rel=up accesskey=u href="#Inetd">Inetd</a>
 <br>
 
 <h4><code>inetd</code> Servers</h4>
@@ -41181,10 +40297,10 @@
 until no more arrive, and then exit.  You must specify which of these
 two techniques the server uses when you configure <code>inetd</code>.
 
 <p><hr>
-Node:<a name="Configuring%20Inetd">Configuring Inetd</a>,
-Previous:<a rel=previous accesskey=p href="#Inetd%20Servers">Inetd Servers</a>,
+Node:<a name="Configuring Inetd">Configuring Inetd</a>,
+Previous:<a rel=previous accesskey=p href="#Inetd Servers">Inetd Servers</a>,
 Up:<a rel=up accesskey=u href="#Inetd">Inetd</a>
 <br>
 
 <h4>Configuring <code>inetd</code></h4>
@@ -41246,10 +40362,10 @@
 <code>SIGHUP</code> signal.  You'll have to use <code>ps</code> to determine the
 process ID of the <code>inetd</code> process as it is not fixed.
 
 <p><hr>
-Node:<a name="Socket%20Options">Socket Options</a>,
-Next:<a rel=next accesskey=n href="#Networks%20Database">Networks Database</a>,
+Node:<a name="Socket Options">Socket Options</a>,
+Next:<a rel=next accesskey=n href="#Networks Database">Networks Database</a>,
 Previous:<a rel=previous accesskey=p href="#Inetd">Inetd</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
@@ -41263,33 +40379,32 @@
 applies to the socket interface, or to a lower-level communications
 protocol interface.
 
 <ul>
-<li><a accesskey=1 href="#Socket%20Option%20Functions">Socket Option Functions</a>:      The basic functions for setting and getting
+<li><a accesskey=1 href="#Socket Option Functions">Socket Option Functions</a>:      The basic functions for setting and getting
                                  socket options. 
-<li><a accesskey=2 href="#Socket-Level%20Options">Socket-Level Options</a>:         Details of the options at the socket level. 
+<li><a accesskey=2 href="#Socket-Level Options">Socket-Level Options</a>:         Details of the options at the socket level. 
 </ul>
 
 <p><hr>
-Node:<a name="Socket%20Option%20Functions">Socket Option Functions</a>,
-Next:<a rel=next accesskey=n href="#Socket-Level%20Options">Socket-Level Options</a>,
-Up:<a rel=up accesskey=u href="#Socket%20Options">Socket Options</a>
+Node:<a name="Socket Option Functions">Socket Option Functions</a>,
+Next:<a rel=next accesskey=n href="#Socket-Level Options">Socket-Level Options</a>,
+Up:<a rel=up accesskey=u href="#Socket Options">Socket Options</a>
 <br>
 
 <h4>Socket Option Functions</h4>
 
 <p>Here are the functions for examining and modifying socket options. 
 They are declared in <code>sys/socket.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getsockopt</b><i> (int <var>socket</var>, int <var>level</var>, int <var>optname</var>, void *<var>optval</var>, socklen_t *<var>optlen-ptr</var>)
-</i></td>
+<td align="left"><code>int <b>getsockopt</b><i> (int <var>socket</var>, int <var>level</var>, int <var>optname</var>, void *<var>optval</var>, socklen_t *<var>optlen-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getsockopt</code> function gets information about the value of
 option <var>optname</var> at level <var>level</var> for socket <var>socket</var>.
 
@@ -41318,16 +40433,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setsockopt</b><i> (int <var>socket</var>, int <var>level</var>, int <var>optname</var>, void *<var>optval</var>, socklen_t <var>optlen</var>)
-</i></td>
+<td align="left"><code>int <b>setsockopt</b><i> (int <var>socket</var>, int <var>level</var>, int <var>optname</var>, void *<var>optval</var>, socklen_t <var>optlen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to set the socket option <var>optname</var> at level
 <var>level</var> for socket <var>socket</var>.  The value of the option is passed
 in the buffer <var>optval</var> of size <var>optlen</var>.
@@ -41335,24 +40449,23 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Socket-Level%20Options">Socket-Level Options</a>,
-Previous:<a rel=previous accesskey=p href="#Socket%20Option%20Functions">Socket Option Functions</a>,
-Up:<a rel=up accesskey=u href="#Socket%20Options">Socket Options</a>
+Node:<a name="Socket-Level Options">Socket-Level Options</a>,
+Previous:<a rel=previous accesskey=p href="#Socket Option Functions">Socket Option Functions</a>,
+Up:<a rel=up accesskey=u href="#Socket Options">Socket Options</a>
 <br>
 
 <h4>Socket-Level Options</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SOL_SOCKET</b><i>
-</i></td>
+<td align="left"><code>int <b>SOL_SOCKET</b><i></i></code></td>
 <td align="right">Constant</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Use this constant as the <var>level</var> argument to <code>getsockopt</code> or
 <code>setsockopt</code> to manipulate the socket-level options described in
 this section. 
@@ -41369,9 +40482,9 @@
 protocol modules.  The value has type <code>int</code>; a nonzero value means
 "yes".
 
 <br><dt><code>SO_REUSEADDR</code>
-<dd>This option controls whether <code>bind</code> (see <a href="#Setting%20Address">Setting Address</a>)
+<dd>This option controls whether <code>bind</code> (see <a href="#Setting Address">Setting Address</a>)
 should permit reuse of local addresses for this socket.  If you enable
 this option, you can actually have two sockets with the same Internet
 port number; but the system won't allow you to use the two
 identically-named sockets in a way that would confuse the Internet.  The
@@ -41395,20 +40508,19 @@
 
 <br><dt><code>SO_LINGER</code>
 <dd>This option specifies what should happen when the socket of a type
 that promises reliable delivery still has untransmitted messages when
-it is closed; see <a href="#Closing%20a%20Socket">Closing a Socket</a>.  The value has type
+it is closed; see <a href="#Closing a Socket">Closing a Socket</a>.  The value has type
 <code>struct linger</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct linger</b><i>
-</i></td>
+<td align="left"><code><b>struct linger</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure type has the following members:
 
 <dl>
@@ -41429,9 +40541,9 @@
 <br><dt><code>SO_OOBINLINE</code>
 <dd>If this option is set, out-of-band data received on the socket is
 placed in the normal input queue.  This permits it to be read using
 <code>read</code> or <code>recv</code> without specifying the <code>MSG_OOB</code>
-flag.  See <a href="#Out-of-Band%20Data">Out-of-Band Data</a>.  The value has type <code>int</code>; a
+flag.  See <a href="#Out-of-Band Data">Out-of-Band Data</a>.  The value has type <code>int</code>; a
 nonzero value means "yes".
 
 <br><dt><code>SO_SNDBUF</code>
 <dd>This option gets or sets the size of the output buffer.  The value is a
@@ -41446,9 +40558,9 @@
 <dd>This option can be used with <code>getsockopt</code> only.  It is used to
 get the socket's communication style.  <code>SO_TYPE</code> is the
 historical name, and <code>SO_STYLE</code> is the preferred name in GNU. 
 The value has type <code>int</code> and its value designates a communication
-style; see <a href="#Communication%20Styles">Communication Styles</a>.
+style; see <a href="#Communication Styles">Communication Styles</a>.
 
 <br><dt><code>SO_ERROR</code>
 <dd>
 This option can be used with <code>getsockopt</code> only.  It is used to reset
@@ -41456,10 +40568,10 @@
 the previous error status. 
 </dl>
 
 <p><hr>
-Node:<a name="Networks%20Database">Networks Database</a>,
-Previous:<a rel=previous accesskey=p href="#Socket%20Options">Socket Options</a>,
+Node:<a name="Networks Database">Networks Database</a>,
+Previous:<a rel=previous accesskey=p href="#Socket Options">Socket Options</a>,
 Up:<a rel=up accesskey=u href="#Sockets">Sockets</a>
 <br>
 
 <h3>Networks Database</h3>
@@ -41472,16 +40584,15 @@
 provide functions to access this database, which are declared in
 <code>netdb.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct netent</b><i>
-</i></td>
+<td align="left"><code><b>struct netent</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is used to represent information about entries in the
 networks database.  It has the following members:
 
@@ -41498,9 +40609,9 @@
 <code>AF_INET</code> for Internet networks.
 
 <br><dt><code>unsigned long int n_net</code>
 <dd>This is the network number.  Network numbers are returned in host
-byte order; see <a href="#Byte%20Order">Byte Order</a>. 
+byte order; see <a href="#Byte Order">Byte Order</a>. 
 </dl>
 </td></tr>
 </table>
 
@@ -41509,32 +40620,30 @@
 information is returned in a statically-allocated structure; you must
 copy the information if you need to save it.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct netent * <b>getnetbyname</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>struct netent * <b>getnetbyname</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getnetbyname</code> function returns information about the network
 named <var>name</var>.  It returns a null pointer if there is no such
 network. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct netent * <b>getnetbyaddr</b><i> (unsigned long int <var>net</var>, int <var>type</var>)
-</i></td>
+<td align="left"><code>struct netent * <b>getnetbyaddr</b><i> (unsigned long int <var>net</var>, int <var>type</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getnetbyaddr</code> function returns information about the network
 of type <var>type</var> with number <var>net</var>.  You should specify a value of
 <code>AF_INET</code> for the <var>type</var> argument for Internet networks.
@@ -41548,16 +40657,15 @@
 <code>getnetent</code> and <code>endnetent</code>.  Be careful when using these
 functions because they are not reentrant.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setnetent</b><i> (int <var>stayopen</var>)
-</i></td>
+<td align="left"><code>void <b>setnetent</b><i> (int <var>stayopen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens and rewinds the networks database.
 
 <p>If the <var>stayopen</var> argument is nonzero, this sets a flag so that
@@ -41568,38 +40676,36 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct netent * <b>getnetent</b><i> (void)
-</i></td>
+<td align="left"><code>struct netent * <b>getnetent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next entry in the networks database.  It
 returns a null pointer if there are no more entries. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endnetent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endnetent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the networks database. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>,
+Node:<a name="Low-Level Terminal Interface">Low-Level Terminal Interface</a>,
 Next:<a rel=next accesskey=n href="#Syslog">Syslog</a>,
 Previous:<a rel=previous accesskey=p href="#Sockets">Sockets</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
@@ -41612,30 +40718,30 @@
 change which characters are used for end-of-file, command-line editing,
 sending signals, and similar control functions.
 
 <p>Most of the functions in this chapter operate on file descriptors. 
-See <a href="#Low-Level%20I%2fO">Low-Level I/O</a>, for more information about what a file
+See <a href="#Low-Level I%2fO">Low-Level I/O</a>, for more information about what a file
 descriptor is and how to open a file descriptor for a terminal device.
 
 <ul>
-<li><a accesskey=1 href="#Is%20It%20a%20Terminal">Is It a Terminal</a>:             How to determine if a file is a terminal
+<li><a accesskey=1 href="#Is It a Terminal">Is It a Terminal</a>:             How to determine if a file is a terminal
 			         device, and what its name is. 
-<li><a accesskey=2 href="#I%2fO%20Queues">I/O Queues</a>:                   About flow control and typeahead. 
-<li><a accesskey=3 href="#Canonical%20or%20Not">Canonical or Not</a>:             Two basic styles of input processing. 
-<li><a accesskey=4 href="#Terminal%20Modes">Terminal Modes</a>:               How to examine and modify flags controlling
+<li><a accesskey=2 href="#I%2fO Queues">I/O Queues</a>:                   About flow control and typeahead. 
+<li><a accesskey=3 href="#Canonical or Not">Canonical or Not</a>:             Two basic styles of input processing. 
+<li><a accesskey=4 href="#Terminal Modes">Terminal Modes</a>:               How to examine and modify flags controlling
 			         details of terminal I/O: echoing,
                                  signals, editing.  Posix. 
-<li><a accesskey=5 href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>:           BSD compatible terminal mode setting
-<li><a accesskey=6 href="#Line%20Control">Line Control</a>:                 Sending break sequences, clearing
+<li><a accesskey=5 href="#BSD Terminal Modes">BSD Terminal Modes</a>:           BSD compatible terminal mode setting
+<li><a accesskey=6 href="#Line Control">Line Control</a>:                 Sending break sequences, clearing
                                  terminal buffers <small>...</small>
-<li><a accesskey=7 href="#Noncanon%20Example">Noncanon Example</a>:             How to read single characters without echo. 
+<li><a accesskey=7 href="#Noncanon Example">Noncanon Example</a>:             How to read single characters without echo. 
 <li><a accesskey=8 href="#Pseudo-Terminals">Pseudo-Terminals</a>:             How to open a pseudo-terminal. 
 </ul>
 
 <p><hr>
-Node:<a name="Is%20It%20a%20Terminal">Is It a Terminal</a>,
-Next:<a rel=next accesskey=n href="#I%2fO%20Queues">I/O Queues</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Node:<a name="Is It a Terminal">Is It a Terminal</a>,
+Next:<a rel=next accesskey=n href="#I%2fO Queues">I/O Queues</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>Identifying Terminals</h3>
 
@@ -41647,35 +40753,33 @@
 <p>Prototypes for the functions in this section are declared in the header
 file <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isatty</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>int <b>isatty</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns <code>1</code> if <var>filedes</var> is a file descriptor
 associated with an open terminal device, and 0 otherwise. 
 </td></tr>
 </table>
 
 <p>If a file descriptor is associated with a terminal, you can get its
 associated file name using the <code>ttyname</code> function.  See also the
-<code>ctermid</code> function, described in <a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>.
+<code>ctermid</code> function, described in <a href="#Identifying the Terminal">Identifying the Terminal</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ttyname</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>char * <b>ttyname</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the file descriptor <var>filedes</var> is associated with a terminal
 device, the <code>ttyname</code> function returns a pointer to a
 statically-allocated, null-terminated string containing the file name of
@@ -41684,16 +40788,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ttyname_r</b><i> (int <var>filedes</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>int <b>ttyname_r</b><i> (int <var>filedes</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ttyname_r</code> function is similar to the <code>ttyname</code> function
 except that it places its result into the user-specified buffer starting
 at <var>buf</var> with length <var>len</var>.
@@ -41716,41 +40819,41 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="I%2fO%20Queues">I/O Queues</a>,
-Next:<a rel=next accesskey=n href="#Canonical%20or%20Not">Canonical or Not</a>,
-Previous:<a rel=previous accesskey=p href="#Is%20It%20a%20Terminal">Is It a Terminal</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Node:<a name="I%2fO Queues">I/O Queues</a>,
+Next:<a rel=next accesskey=n href="#Canonical or Not">Canonical or Not</a>,
+Previous:<a rel=previous accesskey=p href="#Is It a Terminal">Is It a Terminal</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>I/O Queues</h3>
 
 <p>Many of the remaining functions in this section refer to the input and
 output queues of a terminal device.  These queues implement a form of
 buffering <em>within the kernel</em> independent of the buffering
-implemented by I/O streams (see <a href="#I%2fO%20on%20Streams">I/O on Streams</a>).
+implemented by I/O streams (see <a href="#I%2fO on Streams">I/O on Streams</a>).
 
 <p>The <dfn>terminal input queue</dfn> is also sometimes referred to as its
 <dfn>typeahead buffer</dfn>.  It holds the characters that have been received
 from the terminal but not yet read by any process.
 
 <p>The size of the input queue is described by the <code>MAX_INPUT</code> and
-<code>_POSIX_MAX_INPUT</code> parameters; see <a href="#Limits%20for%20Files">Limits for Files</a>.  You
+<code>_POSIX_MAX_INPUT</code> parameters; see <a href="#Limits for Files">Limits for Files</a>.  You
 are guaranteed a queue size of at least <code>MAX_INPUT</code>, but the queue
 might be larger, and might even dynamically change size.  If input flow
 control is enabled by setting the <code>IXOFF</code> input mode bit
-(see <a href="#Input%20Modes">Input Modes</a>), the terminal driver transmits STOP and START
+(see <a href="#Input Modes">Input Modes</a>), the terminal driver transmits STOP and START
 characters to the terminal when necessary to prevent the queue from
 overflowing.  Otherwise, input may be lost if it comes in too fast from
 the terminal.  In canonical mode, all input stays in the queue until a
 newline character is received, so the terminal input queue can fill up
-when you type a very long line.  See <a href="#Canonical%20or%20Not">Canonical or Not</a>.
+when you type a very long line.  See <a href="#Canonical or Not">Canonical or Not</a>.
 
 <p>The <dfn>terminal output queue</dfn> is like the input queue, but for output;
 it contains characters that have been written by processes, but not yet
 transmitted to the terminal.  If output flow control is enabled by
-setting the <code>IXON</code> input mode bit (see <a href="#Input%20Modes">Input Modes</a>), the
+setting the <code>IXON</code> input mode bit (see <a href="#Input Modes">Input Modes</a>), the
 terminal driver obeys START and STOP characters sent by the terminal to
 stop and restart transmission of output.
 
 <p><dfn>Clearing</dfn> the terminal input queue means discarding any characters
@@ -41758,12 +40861,12 @@
 terminal output queue means discarding any characters that have been
 written but not yet transmitted.
 
 <p><hr>
-Node:<a name="Canonical%20or%20Not">Canonical or Not</a>,
-Next:<a rel=next accesskey=n href="#Terminal%20Modes">Terminal Modes</a>,
-Previous:<a rel=previous accesskey=p href="#I%2fO%20Queues">I/O Queues</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Node:<a name="Canonical or Not">Canonical or Not</a>,
+Next:<a rel=next accesskey=n href="#Terminal Modes">Terminal Modes</a>,
+Previous:<a rel=previous accesskey=p href="#I%2fO Queues">I/O Queues</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>Two Styles of Input: Canonical or Not</h3>
 
@@ -41772,41 +40875,41 @@
 
 <p>In <dfn>canonical input processing</dfn> mode, terminal input is processed in
 lines terminated by newline (<code>'\n'</code>), EOF, or EOL characters.  No
 input can be read until an entire line has been typed by the user, and
-the <code>read</code> function (see <a href="#I%2fO%20Primitives">I/O Primitives</a>) returns at most a
+the <code>read</code> function (see <a href="#I%2fO Primitives">I/O Primitives</a>) returns at most a
 single line of input, no matter how many bytes are requested.
 
 <p>In canonical input mode, the operating system provides input editing
 facilities: some characters are interpreted specially to perform editing
 operations within the current line of text, such as ERASE and KILL. 
-See <a href="#Editing%20Characters">Editing Characters</a>.
+See <a href="#Editing Characters">Editing Characters</a>.
 
 <p>The constants <code>_POSIX_MAX_CANON</code> and <code>MAX_CANON</code> parameterize
 the maximum number of bytes which may appear in a single line of
-canonical input.  See <a href="#Limits%20for%20Files">Limits for Files</a>.  You are guaranteed a maximum
+canonical input.  See <a href="#Limits for Files">Limits for Files</a>.  You are guaranteed a maximum
 line length of at least <code>MAX_CANON</code> bytes, but the maximum might be
 larger, and might even dynamically change size.
 
 <p>In <dfn>noncanonical input processing</dfn> mode, characters are not grouped
 into lines, and ERASE and KILL processing is not performed.  The
 granularity with which bytes are read in noncanonical input mode is
-controlled by the MIN and TIME settings.  See <a href="#Noncanonical%20Input">Noncanonical Input</a>.
+controlled by the MIN and TIME settings.  See <a href="#Noncanonical Input">Noncanonical Input</a>.
 
 <p>Most programs use canonical input mode, because this gives the user a
 way to edit input line by line.  The usual reason to use noncanonical
 mode is when the program accepts single-character commands or provides
 its own editing facilities.
 
 <p>The choice of canonical or noncanonical input is controlled by the
 <code>ICANON</code> flag in the <code>c_lflag</code> member of <code>struct termios</code>. 
-See <a href="#Local%20Modes">Local Modes</a>.
+See <a href="#Local Modes">Local Modes</a>.
 
 <p><hr>
-Node:<a name="Terminal%20Modes">Terminal Modes</a>,
-Next:<a rel=next accesskey=n href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>,
-Previous:<a rel=previous accesskey=p href="#Canonical%20or%20Not">Canonical or Not</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Node:<a name="Terminal Modes">Terminal Modes</a>,
+Next:<a rel=next accesskey=n href="#BSD Terminal Modes">BSD Terminal Modes</a>,
+Previous:<a rel=previous accesskey=p href="#Canonical or Not">Canonical or Not</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>Terminal Modes</h3>
 
@@ -41815,32 +40918,32 @@
 constants are all declared in the header file <code>termios.h</code>.
 
 <p>Don't confuse terminal attributes with file attributes.  A device special
 file which is associated with a terminal has file attributes as described
-in <a href="#File%20Attributes">File Attributes</a>.  These are unrelated to the attributes of the
+in <a href="#File Attributes">File Attributes</a>.  These are unrelated to the attributes of the
 terminal device itself, which are discussed in this section.
 
 <ul>
-<li><a accesskey=1 href="#Mode%20Data%20Types">Mode Data Types</a>:              The data type <code>struct termios</code> and
+<li><a accesskey=1 href="#Mode Data Types">Mode Data Types</a>:              The data type <code>struct termios</code> and
                                  related types. 
-<li><a accesskey=2 href="#Mode%20Functions">Mode Functions</a>:               Functions to read and set the terminal
+<li><a accesskey=2 href="#Mode Functions">Mode Functions</a>:               Functions to read and set the terminal
                                  attributes. 
-<li><a accesskey=3 href="#Setting%20Modes">Setting Modes</a>:                The right way to set terminal attributes
+<li><a accesskey=3 href="#Setting Modes">Setting Modes</a>:                The right way to set terminal attributes
                                  reliably. 
-<li><a accesskey=4 href="#Input%20Modes">Input Modes</a>:                  Flags controlling low-level input handling. 
-<li><a accesskey=5 href="#Output%20Modes">Output Modes</a>:                 Flags controlling low-level output handling. 
-<li><a accesskey=6 href="#Control%20Modes">Control Modes</a>:                Flags controlling serial port behavior. 
-<li><a accesskey=7 href="#Local%20Modes">Local Modes</a>:                  Flags controlling high-level input handling. 
-<li><a accesskey=8 href="#Line%20Speed">Line Speed</a>:                   How to read and set the terminal line speed. 
-<li><a accesskey=9 href="#Special%20Characters">Special Characters</a>:           Characters that have special effects,
+<li><a accesskey=4 href="#Input Modes">Input Modes</a>:                  Flags controlling low-level input handling. 
+<li><a accesskey=5 href="#Output Modes">Output Modes</a>:                 Flags controlling low-level output handling. 
+<li><a accesskey=6 href="#Control Modes">Control Modes</a>:                Flags controlling serial port behavior. 
+<li><a accesskey=7 href="#Local Modes">Local Modes</a>:                  Flags controlling high-level input handling. 
+<li><a accesskey=8 href="#Line Speed">Line Speed</a>:                   How to read and set the terminal line speed. 
+<li><a accesskey=9 href="#Special Characters">Special Characters</a>:           Characters that have special effects,
 			         and how to change them. 
-<li><a href="#Noncanonical%20Input">Noncanonical Input</a>:           Controlling how long to wait for input. 
+<li><a href="#Noncanonical Input">Noncanonical Input</a>:           Controlling how long to wait for input. 
 </ul>
 
 <p><hr>
-Node:<a name="Mode%20Data%20Types">Mode Data Types</a>,
-Next:<a rel=next accesskey=n href="#Mode%20Functions">Mode Functions</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Mode Data Types">Mode Data Types</a>,
+Next:<a rel=next accesskey=n href="#Mode Functions">Mode Functions</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Terminal Mode Data Types</h4>
 
@@ -41849,111 +40952,106 @@
 with the functions <code>tcgetattr</code> and <code>tcsetattr</code> to read
 and set the attributes.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct termios</b><i>
-</i></td>
+<td align="left"><code><b>struct termios</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Structure that records all the I/O attributes of a terminal.  The
 structure includes at least the following members:
 
 <dl>
 <dt><code>tcflag_t c_iflag</code>
-<dd>A bit mask specifying flags for input modes; see <a href="#Input%20Modes">Input Modes</a>.
+<dd>A bit mask specifying flags for input modes; see <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>tcflag_t c_oflag</code>
-<dd>A bit mask specifying flags for output modes; see <a href="#Output%20Modes">Output Modes</a>.
+<dd>A bit mask specifying flags for output modes; see <a href="#Output Modes">Output Modes</a>.
 
 <br><dt><code>tcflag_t c_cflag</code>
-<dd>A bit mask specifying flags for control modes; see <a href="#Control%20Modes">Control Modes</a>.
+<dd>A bit mask specifying flags for control modes; see <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>tcflag_t c_lflag</code>
-<dd>A bit mask specifying flags for local modes; see <a href="#Local%20Modes">Local Modes</a>.
+<dd>A bit mask specifying flags for local modes; see <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>cc_t c_cc[NCCS]</code>
 <dd>An array specifying which characters are associated with various
-control functions; see <a href="#Special%20Characters">Special Characters</a>. 
+control functions; see <a href="#Special Characters">Special Characters</a>. 
 </dl>
 
 <p>The <code>struct termios</code> structure also contains members which
 encode input and output transmission speeds, but the representation is
-not specified.  See <a href="#Line%20Speed">Line Speed</a>, for how to examine and store the
+not specified.  See <a href="#Line Speed">Line Speed</a>, for how to examine and store the
 speed values. 
 </td></tr>
 </table>
 
 <p>The following sections describe the details of the members of the
 <code>struct termios</code> structure.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>tcflag_t</b><i>
-</i></td>
+<td align="left"><code><b>tcflag_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an unsigned integer type used to represent the various
 bit masks for terminal flags. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>cc_t</b><i>
-</i></td>
+<td align="left"><code><b>cc_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an unsigned integer type used to represent characters associated
 with various terminal control functions. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>NCCS</b><i>
-</i></td>
+<td align="left"><code>int <b>NCCS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is the number of elements in the <code>c_cc</code>
 array. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Mode%20Functions">Mode Functions</a>,
-Next:<a rel=next accesskey=n href="#Setting%20Modes">Setting Modes</a>,
-Previous:<a rel=previous accesskey=p href="#Mode%20Data%20Types">Mode Data Types</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Mode Functions">Mode Functions</a>,
+Next:<a rel=next accesskey=n href="#Setting Modes">Setting Modes</a>,
+Previous:<a rel=previous accesskey=p href="#Mode Data Types">Mode Data Types</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Terminal Mode Functions</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tcgetattr</b><i> (int <var>filedes</var>, struct termios *<var>termios-p</var>)
-</i></td>
+<td align="left"><code>int <b>tcgetattr</b><i> (int <var>filedes</var>, struct termios *<var>termios-p</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to examine the attributes of the terminal
 device with file descriptor <var>filedes</var>.  The attributes are returned
 in the structure that <var>termios-p</var> points to.
@@ -41972,16 +41070,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tcsetattr</b><i> (int <var>filedes</var>, int <var>when</var>, const struct termios *<var>termios-p</var>)
-</i></td>
+<td align="left"><code>int <b>tcsetattr</b><i> (int <var>filedes</var>, int <var>when</var>, const struct termios *<var>termios-p</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the attributes of the terminal device with file
 descriptor <var>filedes</var>.  The new attributes are taken from the
 structure that <var>termios-p</var> points to.
@@ -42008,17 +41105,17 @@
 and the GNU system.
 
 <p>Using <code>TCSASOFT</code> is exactly the same as setting the <code>CIGNORE</code>
 bit in the <code>c_cflag</code> member of the structure <var>termios-p</var> points
-to.  See <a href="#Control%20Modes">Control Modes</a>, for a description of <code>CIGNORE</code>. 
+to.  See <a href="#Control Modes">Control Modes</a>, for a description of <code>CIGNORE</code>. 
 </dl>
 
 <p>If this function is called from a background process on its controlling
 terminal, normally all processes in the process group are sent a
 <code>SIGTTOU</code> signal, in the same way as if the process were trying to
 write to the terminal.  The exception is if the calling process itself
 is ignoring or blocking <code>SIGTTOU</code> signals, in which case the
-operation is performed and no signal is sent.  See <a href="#Job%20Control">Job Control</a>.
+operation is performed and no signal is sent.  See <a href="#Job Control">Job Control</a>.
 
 <p>If successful, <code>tcsetattr</code> returns 0.  A return value of
 -1 indicates an error.  The following <code>errno</code> error
 conditions are defined for this function:
@@ -42055,12 +41152,12 @@
 single-character, non-echoed mode.  Instead, you have to explicitly
 switch the terminal back and forth between the two modes.
 
 <p><hr>
-Node:<a name="Setting%20Modes">Setting Modes</a>,
-Next:<a rel=next accesskey=n href="#Input%20Modes">Input Modes</a>,
-Previous:<a rel=previous accesskey=p href="#Mode%20Functions">Mode Functions</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Setting Modes">Setting Modes</a>,
+Next:<a rel=next accesskey=n href="#Input Modes">Input Modes</a>,
+Previous:<a rel=previous accesskey=p href="#Mode Functions">Mode Functions</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Setting Terminal Modes Properly</h4>
 
@@ -42115,12 +41212,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Input%20Modes">Input Modes</a>,
-Next:<a rel=next accesskey=n href="#Output%20Modes">Output Modes</a>,
-Previous:<a rel=previous accesskey=p href="#Setting%20Modes">Setting Modes</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Input Modes">Input Modes</a>,
+Next:<a rel=next accesskey=n href="#Output Modes">Output Modes</a>,
+Previous:<a rel=previous accesskey=p href="#Setting Modes">Setting Modes</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Input Modes</h4>
 
@@ -42131,27 +41228,26 @@
 <p>All of these flags are bits in the <code>c_iflag</code> member of the
 <code>struct termios</code> structure.  The member is an integer, and you
 change flags using the operators <code>&amp;</code>, <code>|</code> and <code>^</code>.  Don't
 try to specify the entire value for <code>c_iflag</code>--instead, change
-only specific flags and leave the rest untouched (see <a href="#Setting%20Modes">Setting Modes</a>).
+only specific flags and leave the rest untouched (see <a href="#Setting Modes">Setting Modes</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>INPCK</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>INPCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, input parity checking is enabled.  If it is not set,
 no checking at all is done for parity errors on input; the
 characters are simply passed through to the application.
 
 <p>Parity checking on input processing is independent of whether parity
 detection and generation on the underlying terminal hardware is enabled;
-see <a href="#Control%20Modes">Control Modes</a>.  For example, you could clear the <code>INPCK</code>
+see <a href="#Control Modes">Control Modes</a>.  For example, you could clear the <code>INPCK</code>
 input mode flag and set the <code>PARENB</code> control mode flag to ignore
 parity errors on input, but still generate parity on output.
 
 <p>If this bit is set, what happens when a parity error is detected depends
@@ -42161,31 +41257,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IGNPAR</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IGNPAR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, any byte with a framing or parity error is ignored. 
 This is only useful if <code>INPCK</code> is also set. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>PARMRK</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>PARMRK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, input bytes with parity or framing errors are marked
 when passed to the program.  This bit is meaningful only when
 <code>INPCK</code> is set and <code>IGNPAR</code> is not set.
@@ -42201,31 +41295,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ISTRIP</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ISTRIP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, valid input bytes are stripped to seven bits;
 otherwise, all eight bits are available for programs to read. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IGNBRK</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IGNBRK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, break conditions are ignored.
 
 <p>A <dfn>break condition</dfn> is defined in the context of asynchronous
@@ -42234,16 +41326,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>BRKINT</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>BRKINT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set and <code>IGNBRK</code> is not set, a break condition
 clears the terminal input and output queues and raises a <code>SIGINT</code>
 signal for the foreground process group associated with the terminal.
@@ -42255,16 +41346,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IGNCR</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IGNCR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, carriage return characters (<code>'\r'</code>) are
 discarded on input.  Discarding carriage return may be useful on
 terminals that send both carriage return and linefeed when you type the
@@ -42272,85 +41362,80 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ICRNL</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ICRNL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set and <code>IGNCR</code> is not set, carriage return characters
 (<code>'\r'</code>) received as input are passed to the application as newline
 characters (<code>'\n'</code>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>INLCR</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>INLCR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, newline characters (<code>'\n'</code>) received as input
 are passed to the application as carriage return characters (<code>'\r'</code>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IXOFF</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IXOFF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, start/stop control on input is enabled.  In other
 words, the computer sends STOP and START characters as necessary to
 prevent input from coming in faster than programs are reading it.  The
 idea is that the actual terminal hardware that is generating the input
 data responds to a STOP character by suspending transmission, and to a
-START character by resuming transmission.  See <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>. 
+START character by resuming transmission.  See <a href="#Start%2fStop Characters">Start/Stop Characters</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IXON</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IXON</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, start/stop control on output is enabled.  In other
 words, if the computer receives a STOP character, it suspends output
 until a START character is received.  In this case, the STOP and START
 characters are never passed to the application program.  If this bit is
 not set, then START and STOP can be read as ordinary characters. 
-See <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>. 
+See <a href="#Start%2fStop Characters">Start/Stop Characters</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IXANY</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IXANY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, any input character restarts output when output has
 been suspended with the STOP character.  Otherwise, only the START
 character restarts output.
@@ -42359,16 +41444,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IMAXBEL</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IMAXBEL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, then filling up the terminal input buffer sends a
 BEL character (code <code>007</code>) to the terminal to ring the bell.
 
@@ -42376,12 +41460,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Output%20Modes">Output Modes</a>,
-Next:<a rel=next accesskey=n href="#Control%20Modes">Control Modes</a>,
-Previous:<a rel=previous accesskey=p href="#Input%20Modes">Input Modes</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Output Modes">Output Modes</a>,
+Next:<a rel=next accesskey=n href="#Control Modes">Control Modes</a>,
+Previous:<a rel=previous accesskey=p href="#Input Modes">Input Modes</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Output Modes</h4>
 
@@ -42392,19 +41476,18 @@
 
 <p>The <code>c_oflag</code> member itself is an integer, and you change the flags
 and fields using the operators <code>&amp;</code>, <code>|</code>, and <code>^</code>.  Don't
 try to specify the entire value for <code>c_oflag</code>--instead, change
-only specific flags and leave the rest untouched (see <a href="#Setting%20Modes">Setting Modes</a>).
+only specific flags and leave the rest untouched (see <a href="#Setting Modes">Setting Modes</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>OPOST</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>OPOST</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, output data is processed in some unspecified way so
 that it is displayed appropriately on the terminal device.  This
 typically includes mapping newline characters (<code>'\n'</code>) onto
@@ -42418,57 +41501,54 @@
 systems and the GNU system.  They are effective only if <code>OPOST</code> is
 set.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ONLCR</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ONLCR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, convert the newline character on output into a pair
 of characters, carriage return followed by linefeed. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>OXTABS</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>OXTABS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, convert tab characters on output into the appropriate
 number of spaces to emulate a tab stop every eight columns. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ONOEOT</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ONOEOT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, discard <kbd>C-d</kbd> characters (code <code>004</code>) on
 output.  These characters cause many dial-up terminals to disconnect. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Control%20Modes">Control Modes</a>,
-Next:<a rel=next accesskey=n href="#Local%20Modes">Local Modes</a>,
-Previous:<a rel=previous accesskey=p href="#Output%20Modes">Output Modes</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Control Modes">Control Modes</a>,
+Next:<a rel=next accesskey=n href="#Local Modes">Local Modes</a>,
+Previous:<a rel=previous accesskey=p href="#Output Modes">Output Modes</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Control Modes</h4>
 
@@ -42481,19 +41561,18 @@
 
 <p>The <code>c_cflag</code> member itself is an integer, and you change the flags
 and fields using the operators <code>&amp;</code>, <code>|</code>, and <code>^</code>.  Don't
 try to specify the entire value for <code>c_cflag</code>--instead, change
-only specific flags and leave the rest untouched (see <a href="#Setting%20Modes">Setting Modes</a>).
+only specific flags and leave the rest untouched (see <a href="#Setting Modes">Setting Modes</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CLOCAL</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CLOCAL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, it indicates that the terminal is connected
 "locally" and that the modem status lines (such as carrier detect)
 should be ignored.
@@ -42504,87 +41583,82 @@
 
 <p>If this bit is not set and a modem disconnect is detected, a
 <code>SIGHUP</code> signal is sent to the controlling process group for the
 terminal (if it has one).  Normally, this causes the process to exit;
-see <a href="#Signal%20Handling">Signal Handling</a>.  Reading from the terminal after a disconnect
+see <a href="#Signal Handling">Signal Handling</a>.  Reading from the terminal after a disconnect
 causes an end-of-file condition, and writing causes an <code>EIO</code> error
 to be returned.  The terminal device must be closed and reopened to
 clear the condition. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>HUPCL</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>HUPCL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, a modem disconnect is generated when all processes
 that have the terminal device open have either closed the file or exited. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CREAD</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CREAD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, input can be read from the terminal.  Otherwise,
 input is discarded when it arrives. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CSTOPB</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CSTOPB</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, two stop bits are used.  Otherwise, only one stop bit
 is used. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>PARENB</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>PARENB</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, generation and detection of a parity bit are enabled. 
-See <a href="#Input%20Modes">Input Modes</a>, for information on how input parity errors are handled.
+See <a href="#Input Modes">Input Modes</a>, for information on how input parity errors are handled.
 
 <p>If this bit is not set, no parity bit is added to output characters, and
 input characters are not checked for correct parity. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>PARODD</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>PARODD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This bit is only useful if <code>PARENB</code> is set.  If <code>PARODD</code> is set,
 odd parity is used, otherwise even parity is used. 
 </td></tr>
@@ -42594,72 +41668,67 @@
 character.  You can use the <code>CSIZE</code> macro as a mask to extract the
 value, like this: <code>settings.c_cflag &amp; CSIZE</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CSIZE</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CSIZE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a mask for the number of bits per character. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CS5</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CS5</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This specifies five bits per byte. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CS6</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CS6</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This specifies six bits per byte. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CS7</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CS7</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This specifies seven bits per byte. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CS8</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CS8</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This specifies eight bits per byte. 
 </td></tr>
 </table>
@@ -42667,60 +41736,56 @@
 <p>The following four bits are BSD extensions; this exist only on BSD
 systems and the GNU system.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CCTS_OFLOW</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CCTS_OFLOW</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, enable flow control of output based on the CTS wire
 (RS232 protocol). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CRTS_IFLOW</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CRTS_IFLOW</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, enable flow control of input based on the RTS wire
 (RS232 protocol). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>MDMBUF</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>MDMBUF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, enable carrier-based flow control of output. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>CIGNORE</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>CIGNORE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, it says to ignore the control modes and line speed
 values entirely.  This is only meaningful in a call to <code>tcsetattr</code>.
 
@@ -42735,66 +41800,63 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Local%20Modes">Local Modes</a>,
-Next:<a rel=next accesskey=n href="#Line%20Speed">Line Speed</a>,
-Previous:<a rel=previous accesskey=p href="#Control%20Modes">Control Modes</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Local Modes">Local Modes</a>,
+Next:<a rel=next accesskey=n href="#Line Speed">Line Speed</a>,
+Previous:<a rel=previous accesskey=p href="#Control Modes">Control Modes</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Local Modes</h4>
 
 <p>This section describes the flags for the <code>c_lflag</code> member of the
 <code>struct termios</code> structure.  These flags generally control
 higher-level aspects of input processing than the input modes flags
-described in <a href="#Input%20Modes">Input Modes</a>, such as echoing, signals, and the choice
+described in <a href="#Input Modes">Input Modes</a>, such as echoing, signals, and the choice
 of canonical or noncanonical input.
 
 <p>The <code>c_lflag</code> member itself is an integer, and you change the flags
 and fields using the operators <code>&amp;</code>, <code>|</code>, and <code>^</code>.  Don't
 try to specify the entire value for <code>c_lflag</code>--instead, change
-only specific flags and leave the rest untouched (see <a href="#Setting%20Modes">Setting Modes</a>).
+only specific flags and leave the rest untouched (see <a href="#Setting Modes">Setting Modes</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ICANON</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ICANON</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This bit, if set, enables canonical input processing mode.  Otherwise,
-input is processed in noncanonical mode.  See <a href="#Canonical%20or%20Not">Canonical or Not</a>. 
+input is processed in noncanonical mode.  See <a href="#Canonical or Not">Canonical or Not</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ECHO</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ECHO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, echoing of input characters back to the terminal
 is enabled. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ECHOE</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ECHOE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, echoing indicates erasure of input with the ERASE
 character by erasing the last character in the current line from the
 screen.  Otherwise, the character erased is re-echoed to show what has
@@ -42806,16 +41868,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ECHOPRT</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ECHOPRT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This bit is like <code>ECHOE</code>, enables display of the ERASE character in
 a way that is geared to a hardcopy terminal.  When you type the ERASE
 character, a <code>\</code> character is printed followed by the first
@@ -42828,16 +41889,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ECHOK</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ECHOK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This bit enables special display of the KILL character by moving to a
 new line after echoing the KILL character normally.  The behavior of
 <code>ECHOKE</code> (below) is nicer to look at.
@@ -42853,16 +41913,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ECHOKE</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ECHOKE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This bit is similar to <code>ECHOK</code>.  It enables special display of the
 KILL character by erasing on the screen the entire line that has been
 killed.  This is a BSD extension, and exists only in BSD systems and the
@@ -42870,32 +41929,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ECHONL</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ECHONL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set and the <code>ICANON</code> bit is also set, then the
 newline (<code>'\n'</code>) character is echoed even if the <code>ECHO</code> bit
 is not set. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ECHOCTL</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ECHOCTL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set and the <code>ECHO</code> bit is also set, echo control
 characters with <code>^</code> followed by the corresponding text character. 
 Thus, control-A echoes as <code>^A</code>.  This is usually the preferred mode
@@ -42907,16 +41964,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ISIG</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ISIG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This bit controls whether the INTR, QUIT, and SUSP characters are
 recognized.  The functions associated with these characters are performed
 if and only if this bit is set.  Being in canonical or noncanonical
@@ -42927,74 +41983,70 @@
 user-unfriendly.  If you clear this bit, your program should provide
 some alternate interface that allows the user to interactively send the
 signals associated with these characters, or to escape from the program.
 
-<p>See <a href="#Signal%20Characters">Signal Characters</a>. 
+<p>See <a href="#Signal Characters">Signal Characters</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>IEXTEN</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>IEXTEN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 POSIX.1 gives <code>IEXTEN</code> implementation-defined meaning,
 so you cannot rely on this interpretation on all systems.
 
 <p>On BSD systems and the GNU system, it enables the LNEXT and DISCARD characters. 
-See <a href="#Other%20Special">Other Special</a>. 
+See <a href="#Other Special">Other Special</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>NOFLSH</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>NOFLSH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Normally, the INTR, QUIT, and SUSP characters cause input and output
 queues for the terminal to be cleared.  If this bit is set, the queues
 are not cleared. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>TOSTOP</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>TOSTOP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set and the system supports job control, then
 <code>SIGTTOU</code> signals are generated by background processes that
-attempt to write to the terminal.  See <a href="#Access%20to%20the%20Terminal">Access to the Terminal</a>. 
+attempt to write to the terminal.  See <a href="#Access to the Terminal">Access to the Terminal</a>. 
 </td></tr>
 </table>
 
 <p>The following bits are BSD extensions; they exist only in BSD systems
 and the GNU system.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>ALTWERASE</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>ALTWERASE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This bit determines how far the WERASE character should erase.  The
 WERASE character erases back to the beginning of a word; the question
 is, where do words begin?
@@ -43003,63 +42055,60 @@
 character following a whitespace character.  If the bit is set, then the
 beginning of a word is an alphanumeric character or underscore following
 a character which is none of those.
 
-<p>See <a href="#Editing%20Characters">Editing Characters</a>, for more information about the WERASE character. 
+<p>See <a href="#Editing Characters">Editing Characters</a>, for more information about the WERASE character. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>FLUSHO</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>FLUSHO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the bit that toggles when the user types the DISCARD character. 
-While this bit is set, all output is discarded.  See <a href="#Other%20Special">Other Special</a>. 
+While this bit is set, all output is discarded.  See <a href="#Other Special">Other Special</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>NOKERNINFO</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>NOKERNINFO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Setting this bit disables handling of the STATUS character. 
-See <a href="#Other%20Special">Other Special</a>. 
+See <a href="#Other Special">Other Special</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">tcflag_t <b>PENDIN</b><i>
-</i></td>
+<td align="left"><code>tcflag_t <b>PENDIN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set, it indicates that there is a line of input that
 needs to be reprinted.  Typing the REPRINT character sets this bit; the
-bit remains set until reprinting is finished.  See <a href="#Editing%20Characters">Editing Characters</a>. 
+bit remains set until reprinting is finished.  See <a href="#Editing Characters">Editing Characters</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Line%20Speed">Line Speed</a>,
-Next:<a rel=next accesskey=n href="#Special%20Characters">Special Characters</a>,
-Previous:<a rel=previous accesskey=p href="#Local%20Modes">Local Modes</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Line Speed">Line Speed</a>,
+Next:<a rel=next accesskey=n href="#Special Characters">Special Characters</a>,
+Previous:<a rel=previous accesskey=p href="#Local Modes">Local Modes</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Line Speed</h4>
 
@@ -43090,46 +42139,43 @@
 directly.  Instead, you should use the following functions to read and
 store them:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">speed_t <b>cfgetospeed</b><i> (const struct termios *<var>termios-p</var>)
-</i></td>
+<td align="left"><code>speed_t <b>cfgetospeed</b><i> (const struct termios *<var>termios-p</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the output line speed stored in the structure
 <code>*<var>termios-p</var></code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">speed_t <b>cfgetispeed</b><i> (const struct termios *<var>termios-p</var>)
-</i></td>
+<td align="left"><code>speed_t <b>cfgetispeed</b><i> (const struct termios *<var>termios-p</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the input line speed stored in the structure
 <code>*<var>termios-p</var></code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>cfsetospeed</b><i> (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)
-</i></td>
+<td align="left"><code>int <b>cfsetospeed</b><i> (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function stores <var>speed</var> in <code>*<var>termios-p</var></code> as the output
 speed.  The normal return value is 0; a value of -1
 indicates an error.  If <var>speed</var> is not a speed, <code>cfsetospeed</code>
@@ -43137,16 +42183,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>cfsetispeed</b><i> (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)
-</i></td>
+<td align="left"><code>int <b>cfsetispeed</b><i> (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function stores <var>speed</var> in <code>*<var>termios-p</var></code> as the input
 speed.  The normal return value is 0; a value of -1
 indicates an error.  If <var>speed</var> is not a speed, <code>cfsetospeed</code>
@@ -43154,16 +42199,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>cfsetspeed</b><i> (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)
-</i></td>
+<td align="left"><code>int <b>cfsetspeed</b><i> (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function stores <var>speed</var> in <code>*<var>termios-p</var></code> as both the
 input and output speeds.  The normal return value is 0; a value
 of -1 indicates an error.  If <var>speed</var> is not a speed,
@@ -43172,16 +42216,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>speed_t</b><i>
-</i></td>
+<td align="left"><code><b>speed_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>speed_t</code> type is an unsigned integer data type used to
 represent line speeds. 
 </td></tr>
@@ -43216,12 +42259,12 @@
 alias for <code>B19200</code> and <code>EXTB</code> is an alias for <code>B38400</code>. 
 These aliases are obsolete.
 
 <p><hr>
-Node:<a name="Special%20Characters">Special Characters</a>,
-Next:<a rel=next accesskey=n href="#Noncanonical%20Input">Noncanonical Input</a>,
-Previous:<a rel=previous accesskey=p href="#Line%20Speed">Line Speed</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Special Characters">Special Characters</a>,
+Next:<a rel=next accesskey=n href="#Noncanonical Input">Noncanonical Input</a>,
+Previous:<a rel=previous accesskey=p href="#Line Speed">Line Speed</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Special Characters</h4>
 
@@ -43242,42 +42285,41 @@
 specifies <code>=</code> as the INTR character.
 
 <p>On some systems, you can disable a particular special character function
 by specifying the value <code>_POSIX_VDISABLE</code> for that role.  This
-value is unequal to any possible character code.  See <a href="#Options%20for%20Files">Options for Files</a>, for more information about how to tell whether the operating
+value is unequal to any possible character code.  See <a href="#Options for Files">Options for Files</a>, for more information about how to tell whether the operating
 system you are using supports <code>_POSIX_VDISABLE</code>.
 
 <ul>
-<li><a accesskey=1 href="#Editing%20Characters">Editing Characters</a>:           Special characters that terminate lines and
+<li><a accesskey=1 href="#Editing Characters">Editing Characters</a>:           Special characters that terminate lines and
                                   delete text, and other editing functions. 
-<li><a accesskey=2 href="#Signal%20Characters">Signal Characters</a>:            Special characters that send or raise signals
+<li><a accesskey=2 href="#Signal Characters">Signal Characters</a>:            Special characters that send or raise signals
                                   to or for certain classes of processes. 
-<li><a accesskey=3 href="#Start%2fStop%20Characters">Start/Stop Characters</a>:        Special characters that suspend or resume
+<li><a accesskey=3 href="#Start%2fStop Characters">Start/Stop Characters</a>:        Special characters that suspend or resume
                                   suspended output. 
-<li><a accesskey=4 href="#Other%20Special">Other Special</a>: 		Other special characters for BSD systems:
+<li><a accesskey=4 href="#Other Special">Other Special</a>: 		Other special characters for BSD systems:
 				  they can discard output, and print status. 
 </ul>
 
 <p><hr>
-Node:<a name="Editing%20Characters">Editing Characters</a>,
-Next:<a rel=next accesskey=n href="#Signal%20Characters">Signal Characters</a>,
-Up:<a rel=up accesskey=u href="#Special%20Characters">Special Characters</a>
+Node:<a name="Editing Characters">Editing Characters</a>,
+Next:<a rel=next accesskey=n href="#Signal Characters">Signal Characters</a>,
+Up:<a rel=up accesskey=u href="#Special Characters">Special Characters</a>
 <br>
 
 <h5>Characters for Input Editing</h5>
 
 <p>These special characters are active only in canonical input mode. 
-See <a href="#Canonical%20or%20Not">Canonical or Not</a>.
+See <a href="#Canonical or Not">Canonical or Not</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VEOF</b><i>
-</i></td>
+<td align="left"><code>int <b>VEOF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the EOF character in the special control
 character array.  <code><var>termios</var>.c_cc[VEOF]</code> holds the character
 itself.
@@ -43292,16 +42334,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VEOL</b><i>
-</i></td>
+<td align="left"><code>int <b>VEOL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the EOL character in the special control
 character array.  <code><var>termios</var>.c_cc[VEOL]</code> holds the character
 itself.
@@ -43316,16 +42357,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VEOL2</b><i>
-</i></td>
+<td align="left"><code>int <b>VEOL2</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the EOL2 character in the special control
 character array.  <code><var>termios</var>.c_cc[VEOL2]</code> holds the character
 itself.
@@ -43340,16 +42380,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VERASE</b><i>
-</i></td>
+<td align="left"><code>int <b>VERASE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the ERASE character in the special control
 character array.  <code><var>termios</var>.c_cc[VERASE]</code> holds the
 character itself.
@@ -43365,16 +42404,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VWERASE</b><i>
-</i></td>
+<td align="left"><code>int <b>VWERASE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the WERASE character in the special control
 character array.  <code><var>termios</var>.c_cc[VWERASE]</code> holds the character
 itself.
@@ -43383,9 +42421,9 @@
 entire word of prior input, and any whitespace after it; whitespace
 characters before the word are not erased.
 
 <p>The definition of a "word" depends on the setting of the
-<code>ALTWERASE</code> mode; see <a href="#Local%20Modes">Local Modes</a>.
+<code>ALTWERASE</code> mode; see <a href="#Local Modes">Local Modes</a>.
 
 <p>If the <code>ALTWERASE</code> mode is not set, a word is defined as a sequence
 of any characters except space or tab.
 
@@ -43399,16 +42437,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VKILL</b><i>
-</i></td>
+<td align="left"><code>int <b>VKILL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the KILL character in the special control
 character array.  <code><var>termios</var>.c_cc[VKILL]</code> holds the character
 itself.
@@ -43421,16 +42458,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VREPRINT</b><i>
-</i></td>
+<td align="left"><code>int <b>VREPRINT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the REPRINT character in the special control
 character array.  <code><var>termios</var>.c_cc[VREPRINT]</code> holds the character
 itself.
@@ -43445,84 +42481,81 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Signal%20Characters">Signal Characters</a>,
-Next:<a rel=next accesskey=n href="#Start%2fStop%20Characters">Start/Stop Characters</a>,
-Previous:<a rel=previous accesskey=p href="#Editing%20Characters">Editing Characters</a>,
-Up:<a rel=up accesskey=u href="#Special%20Characters">Special Characters</a>
+Node:<a name="Signal Characters">Signal Characters</a>,
+Next:<a rel=next accesskey=n href="#Start%2fStop Characters">Start/Stop Characters</a>,
+Previous:<a rel=previous accesskey=p href="#Editing Characters">Editing Characters</a>,
+Up:<a rel=up accesskey=u href="#Special Characters">Special Characters</a>
 <br>
 
 <h5>Characters that Cause Signals</h5>
 
 <p>These special characters may be active in either canonical or noncanonical
-input mode, but only when the <code>ISIG</code> flag is set (see <a href="#Local%20Modes">Local Modes</a>).
+input mode, but only when the <code>ISIG</code> flag is set (see <a href="#Local Modes">Local Modes</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VINTR</b><i>
-</i></td>
+<td align="left"><code>int <b>VINTR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the INTR character in the special control
 character array.  <code><var>termios</var>.c_cc[VINTR]</code> holds the character
 itself.
 
 <p>The INTR (interrupt) character raises a <code>SIGINT</code> signal for all
 processes in the foreground job associated with the terminal.  The INTR
-character itself is then discarded.  See <a href="#Signal%20Handling">Signal Handling</a>, for more
+character itself is then discarded.  See <a href="#Signal Handling">Signal Handling</a>, for more
 information about signals.
 
 <p>Typically, the INTR character is <kbd>C-c</kbd>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VQUIT</b><i>
-</i></td>
+<td align="left"><code>int <b>VQUIT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the QUIT character in the special control
 character array.  <code><var>termios</var>.c_cc[VQUIT]</code> holds the character
 itself.
 
 <p>The QUIT character raises a <code>SIGQUIT</code> signal for all processes in
 the foreground job associated with the terminal.  The QUIT character
-itself is then discarded.  See <a href="#Signal%20Handling">Signal Handling</a>, for more information
+itself is then discarded.  See <a href="#Signal Handling">Signal Handling</a>, for more information
 about signals.
 
 <p>Typically, the QUIT character is <kbd>C-\</kbd>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VSUSP</b><i>
-</i></td>
+<td align="left"><code>int <b>VSUSP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the SUSP character in the special control
 character array.  <code><var>termios</var>.c_cc[VSUSP]</code> holds the character
 itself.
 
 <p>The SUSP (suspend) character is recognized only if the implementation
-supports job control (see <a href="#Job%20Control">Job Control</a>).  It causes a <code>SIGTSTP</code>
+supports job control (see <a href="#Job Control">Job Control</a>).  It causes a <code>SIGTSTP</code>
 signal to be sent to all processes in the foreground job associated with
 the terminal.  The SUSP character itself is then discarded. 
-See <a href="#Signal%20Handling">Signal Handling</a>, for more information about signals.
+See <a href="#Signal Handling">Signal Handling</a>, for more information about signals.
 
 <p>Typically, the SUSP character is <kbd>C-z</kbd>. 
 </td></tr>
 </table>
@@ -43531,58 +42564,56 @@
 character.  If your program does this, it should provide some other
 mechanism for the user to stop the job.  When the user invokes this
 mechanism, the program should send a <code>SIGTSTP</code> signal to the
 process group of the process, not just to the process itself. 
-See <a href="#Signaling%20Another%20Process">Signaling Another Process</a>.
+See <a href="#Signaling Another Process">Signaling Another Process</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VDSUSP</b><i>
-</i></td>
+<td align="left"><code>int <b>VDSUSP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the DSUSP character in the special control
 character array.  <code><var>termios</var>.c_cc[VDSUSP]</code> holds the character
 itself.
 
 <p>The DSUSP (suspend) character is recognized only if the implementation
-supports job control (see <a href="#Job%20Control">Job Control</a>).  It sends a <code>SIGTSTP</code>
+supports job control (see <a href="#Job Control">Job Control</a>).  It sends a <code>SIGTSTP</code>
 signal, like the SUSP character, but not right away--only when the
 program tries to read it as input.  Not all systems with job control
 support DSUSP; only BSD-compatible systems (including the GNU system).
 
-<p>See <a href="#Signal%20Handling">Signal Handling</a>, for more information about signals.
+<p>See <a href="#Signal Handling">Signal Handling</a>, for more information about signals.
 
 <p>Typically, the DSUSP character is <kbd>C-y</kbd>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Start%2fStop%20Characters">Start/Stop Characters</a>,
-Next:<a rel=next accesskey=n href="#Other%20Special">Other Special</a>,
-Previous:<a rel=previous accesskey=p href="#Signal%20Characters">Signal Characters</a>,
-Up:<a rel=up accesskey=u href="#Special%20Characters">Special Characters</a>
+Node:<a name="Start%2fStop Characters">Start/Stop Characters</a>,
+Next:<a rel=next accesskey=n href="#Other Special">Other Special</a>,
+Previous:<a rel=previous accesskey=p href="#Signal Characters">Signal Characters</a>,
+Up:<a rel=up accesskey=u href="#Special Characters">Special Characters</a>
 <br>
 
 <h5>Special Characters for Flow Control</h5>
 
 <p>These special characters may be active in either canonical or noncanonical
 input mode, but their use is controlled by the flags <code>IXON</code> and
-<code>IXOFF</code> (see <a href="#Input%20Modes">Input Modes</a>).
+<code>IXOFF</code> (see <a href="#Input Modes">Input Modes</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VSTART</b><i>
-</i></td>
+<td align="left"><code>int <b>VSTART</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the START character in the special control
 character array.  <code><var>termios</var>.c_cc[VSTART]</code> holds the
 character itself.
@@ -43601,16 +42632,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VSTOP</b><i>
-</i></td>
+<td align="left"><code>int <b>VSTOP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the STOP character in the special control
 character array.  <code><var>termios</var>.c_cc[VSTOP]</code> holds the character
 itself.
@@ -43627,26 +42657,25 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Other%20Special">Other Special</a>,
-Previous:<a rel=previous accesskey=p href="#Start%2fStop%20Characters">Start/Stop Characters</a>,
-Up:<a rel=up accesskey=u href="#Special%20Characters">Special Characters</a>
+Node:<a name="Other Special">Other Special</a>,
+Previous:<a rel=previous accesskey=p href="#Start%2fStop Characters">Start/Stop Characters</a>,
+Up:<a rel=up accesskey=u href="#Special Characters">Special Characters</a>
 <br>
 
 <h5>Other Special Characters</h5>
 
 <p>These special characters exist only in BSD systems and the GNU system.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VLNEXT</b><i>
-</i></td>
+<td align="left"><code>int <b>VLNEXT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the LNEXT character in the special control
 character array.  <code><var>termios</var>.c_cc[VLNEXT]</code> holds the character
 itself.
@@ -43662,16 +42691,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VDISCARD</b><i>
-</i></td>
+<td align="left"><code>int <b>VDISCARD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the DISCARD character in the special control
 character array.  <code><var>termios</var>.c_cc[VDISCARD]</code> holds the character
 itself.
@@ -43684,16 +42712,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VSTATUS</b><i>
-</i></td>
+<td align="left"><code>int <b>VSTATUS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the STATUS character in the special control
 character array.  <code><var>termios</var>.c_cc[VSTATUS]</code> holds the character
 itself.
@@ -43706,11 +42733,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Noncanonical%20Input">Noncanonical Input</a>,
-Previous:<a rel=previous accesskey=p href="#Special%20Characters">Special Characters</a>,
-Up:<a rel=up accesskey=u href="#Terminal%20Modes">Terminal Modes</a>
+Node:<a name="Noncanonical Input">Noncanonical Input</a>,
+Previous:<a rel=previous accesskey=p href="#Special Characters">Special Characters</a>,
+Up:<a rel=up accesskey=u href="#Terminal Modes">Terminal Modes</a>
 <br>
 
 <h4>Noncanonical Input</h4>
 
@@ -43734,16 +42761,15 @@
 <code>VMAX</code> are the names for the indices in the array of the MIN and
 TIME slots.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VMIN</b><i>
-</i></td>
+<td align="left"><code>int <b>VMIN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the MIN slot in the <code>c_cc</code> array.  Thus,
 <code><var>termios</var>.c_cc[VMIN]</code> is the value itself.
 
@@ -43753,16 +42779,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>VTIME</b><i>
-</i></td>
+<td align="left"><code>int <b>VTIME</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the subscript for the TIME slot in the <code>c_cc</code> array.  Thus,
 <code><var>termios</var>.c_cc[VTIME]</code> is the value itself.
 
@@ -43825,16 +42850,15 @@
 isn't very clean.  The GNU library allocates separate slots for these
 uses.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>cfmakeraw</b><i> (struct termios *<var>termios-p</var>)
-</i></td>
+<td align="left"><code>int <b>cfmakeraw</b><i> (struct termios *<var>termios-p</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function provides an easy way to set up <code>*<var>termios-p</var></code> for
 what has traditionally been called "raw mode" in BSD.  This uses
 noncanonical input, and turns off most processing to give an unmodified
@@ -43851,34 +42875,33 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="BSD%20Terminal%20Modes">BSD Terminal Modes</a>,
-Next:<a rel=next accesskey=n href="#Line%20Control">Line Control</a>,
-Previous:<a rel=previous accesskey=p href="#Terminal%20Modes">Terminal Modes</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Node:<a name="BSD Terminal Modes">BSD Terminal Modes</a>,
+Next:<a rel=next accesskey=n href="#Line Control">Line Control</a>,
+Previous:<a rel=previous accesskey=p href="#Terminal Modes">Terminal Modes</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>BSD Terminal Modes</h3>
 
 <p>The usual way to get and set terminal modes is with the functions described
-in <a href="#Terminal%20Modes">Terminal Modes</a>.  However, on some systems you can use the
+in <a href="#Terminal Modes">Terminal Modes</a>.  However, on some systems you can use the
 BSD-derived functions in this section to do some of the same thing.  On
 many systems, these functions do not exist.  Even with the GNU C library,
 the functions simply fail with <code>errno</code> = <code>ENOSYS</code> with many
 kernels, including Linux.
 
 <p>The symbols used in this section are declared in <code>sgtty.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sgttyb</b><i>
-</i></td>
+<td align="left"><code><b>struct sgttyb</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is an input or output parameter list for <code>gtty</code> and
 <code>stty</code>.
 
@@ -43897,16 +42920,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>gtty</b><i> (int <var>filedes</var>, struct sgttyb *<var>attributes</var>)
-</i></td>
+<td align="left"><code>int <b>gtty</b><i> (int <var>filedes</var>, struct sgttyb *<var>attributes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function gets the attributes of a terminal.
 
 <p><code>gtty</code> sets *<var>attributes</var> to describe the terminal attributes
@@ -43914,16 +42936,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>stty</b><i> (int <var>filedes</var>, struct sgttyb * attributes)
-</i></td>
+<td align="left"><code>int <b>stty</b><i> (int <var>filedes</var>, struct sgttyb * attributes)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function sets the attributes of a terminal.
 
@@ -43932,12 +42953,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Line%20Control">Line Control</a>,
-Next:<a rel=next accesskey=n href="#Noncanon%20Example">Noncanon Example</a>,
-Previous:<a rel=previous accesskey=p href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Node:<a name="Line Control">Line Control</a>,
+Next:<a rel=next accesskey=n href="#Noncanon Example">Noncanon Example</a>,
+Previous:<a rel=previous accesskey=p href="#BSD Terminal Modes">BSD Terminal Modes</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>Line Control Functions</h3>
 
@@ -43946,19 +42967,18 @@
 output: if any of these functions is used by a background process on its
 controlling terminal, normally all processes in the process group are
 sent a <code>SIGTTOU</code> signal.  The exception is if the calling process
 itself is ignoring or blocking <code>SIGTTOU</code> signals, in which case the
-operation is performed and no signal is sent.  See <a href="#Job%20Control">Job Control</a>.
+operation is performed and no signal is sent.  See <a href="#Job Control">Job Control</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tcsendbreak</b><i> (int <var>filedes</var>, int <var>duration</var>)
-</i></td>
+<td align="left"><code>int <b>tcsendbreak</b><i> (int <var>filedes</var>, int <var>duration</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function generates a break condition by transmitting a stream of
 zero bits on the terminal associated with the file descriptor
 <var>filedes</var>.  The duration of the break is controlled by the
@@ -43982,16 +43002,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tcdrain</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>int <b>tcdrain</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>tcdrain</code> function waits until all queued
 output to the terminal <var>filedes</var> has been transmitted.
 
@@ -44014,22 +43033,21 @@
 <dd>The <var>filedes</var> is not associated with a terminal device.
 
 <br><dt><code>EINTR</code>
 <dd>The operation was interrupted by delivery of a signal. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>. 
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>. 
 </dl>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tcflush</b><i> (int <var>filedes</var>, int <var>queue</var>)
-</i></td>
+<td align="left"><code>int <b>tcflush</b><i> (int <var>filedes</var>, int <var>queue</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>tcflush</code> function is used to clear the input and/or output
 queues associated with the terminal file <var>filedes</var>.  The <var>queue</var>
 argument specifies which queue(s) to clear, and can be one of the
@@ -44072,16 +43090,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tcflow</b><i> (int <var>filedes</var>, int <var>action</var>)
-</i></td>
+<td align="left"><code>int <b>tcflow</b><i> (int <var>filedes</var>, int <var>action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>tcflow</code> function is used to perform operations relating to
 XON/XOFF flow control on the terminal file specified by <var>filedes</var>.
 
@@ -44101,9 +43118,9 @@
 <br><dt><code>TCION</code>
 <dd>Transmit a START character. 
 </dl>
 
-<p>For more information about the STOP and START characters, see <a href="#Special%20Characters">Special Characters</a>.
+<p>For more information about the STOP and START characters, see <a href="#Special Characters">Special Characters</a>.
 
 <p>The return value is normally zero.  In the event of an error, a value
 of -1 is returned.  The following <code>errno</code> error conditions
 are defined for this function:
@@ -44121,12 +43138,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Noncanon%20Example">Noncanon Example</a>,
+Node:<a name="Noncanon Example">Noncanon Example</a>,
 Next:<a rel=next accesskey=n href="#Pseudo-Terminals">Pseudo-Terminals</a>,
-Previous:<a rel=previous accesskey=p href="#Line%20Control">Line Control</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Previous:<a rel=previous accesskey=p href="#Line Control">Line Control</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>Noncanonical Mode Example</h3>
 
@@ -44197,21 +43214,21 @@
 </pre>
 
 <p>This program is careful to restore the original terminal modes before
 exiting or terminating with a signal.  It uses the <code>atexit</code>
-function (see <a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>) to make sure this is done
+function (see <a href="#Cleanups on Exit">Cleanups on Exit</a>) to make sure this is done
 by <code>exit</code>.
 
 <p>The shell is supposed to take care of resetting the terminal modes when
-a process is stopped or continued; see <a href="#Job%20Control">Job Control</a>.  But some
+a process is stopped or continued; see <a href="#Job Control">Job Control</a>.  But some
 existing shells do not actually do this, so you may wish to establish
 handlers for job control signals that reset terminal modes.  The above
 example does so.
 
 <p><hr>
 Node:<a name="Pseudo-Terminals">Pseudo-Terminals</a>,
-Previous:<a rel=previous accesskey=p href="#Noncanon%20Example">Noncanon Example</a>,
-Up:<a rel=up accesskey=u href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+Previous:<a rel=previous accesskey=p href="#Noncanon Example">Noncanon Example</a>,
+Up:<a rel=up accesskey=u href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <br>
 
 <h3>Pseudo-Terminals</h3>
 
@@ -44227,15 +43244,15 @@
 implement their terminal emulation functionality.
 
 <ul>
 <li><a accesskey=1 href="#Allocation">Allocation</a>:              Allocating a pseudo terminal. 
-<li><a accesskey=2 href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>:   How to open both sides of a
+<li><a accesskey=2 href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>:   How to open both sides of a
                             pseudo-terminal in a single operation. 
 </ul>
 
 <p><hr>
 Node:<a name="Allocation">Allocation</a>,
-Next:<a rel=next accesskey=n href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>,
+Next:<a rel=next accesskey=n href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>,
 Up:<a rel=up accesskey=u href="#Pseudo-Terminals">Pseudo-Terminals</a>
 <br>
 
 <h4>Allocating Pseudo-Terminals</h4>
@@ -44244,16 +43261,15 @@
 and for making this pseudo-terminal available for actual use.  These
 functions are declared in the header file <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpt</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>getpt</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getpt</code> function returns a new file descriptor for the next
 available master pseudo-terminal.  The normal return value from
 <code>getpt</code> is a non-negative integer file descriptor.  In the case of
@@ -44269,30 +43285,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>grantpt</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>int <b>grantpt</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>grantpt</code> function changes the ownership and access permission
 of the slave pseudo-terminal device corresponding to the master
 pseudo-terminal device associated with the file descriptor
 <var>filedes</var>.  The owner is set from the real user ID of the calling
-process (see <a href="#Process%20Persona">Process Persona</a>), and the group is set to a special
+process (see <a href="#Process Persona">Process Persona</a>), and the group is set to a special
 group (typically <dfn>tty</dfn>) or from the real group ID of the calling
 process.  The access permission is set such that the file is both
 readable and writable by the owner and only writable by the group.
 
 <p>On some systems this function is implemented by invoking a special
-<code>setuid</code> root program (see <a href="#How%20Change%20Persona">How Change Persona</a>).  As a
+<code>setuid</code> root program (see <a href="#How Change Persona">How Change Persona</a>).  As a
 consequence, installing a signal handler for the <code>SIGCHLD</code> signal
-(see <a href="#Job%20Control%20Signals">Job Control Signals</a>) may interfere with a call to
+(see <a href="#Job Control Signals">Job Control Signals</a>) may interfere with a call to
 <code>grantpt</code>.
 
 <p>The normal return value from <code>grantpt</code> is 0; a value of
 -1 is returned in case of failure.  The following <code>errno</code>
@@ -44314,16 +43329,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>unlockpt</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>int <b>unlockpt</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>unlockpt</code> function unlocks the slave pseudo-terminal device
 corresponding to the master pseudo-terminal device associated with the
 file descriptor <var>filedes</var>.  On many systems, the slave can only be
@@ -44345,16 +43359,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ptsname</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>char * <b>ptsname</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the file descriptor <var>filedes</var> is associated with a
 master pseudo-terminal device, the <code>ptsname</code> function returns a
 pointer to a statically-allocated, null-terminated string containing the
@@ -44363,16 +43376,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ptsname_r</b><i> (int <var>filedes</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>int <b>ptsname_r</b><i> (int <var>filedes</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ptsname_r</code> function is similar to the <code>ptsname</code> function
 except that it places its result into the user-specified buffer starting
 at <var>buf</var> with length <var>len</var>.
@@ -44427,9 +43439,9 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>,
+Node:<a name="Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>,
 Previous:<a rel=previous accesskey=p href="#Allocation">Allocation</a>,
 Up:<a rel=up accesskey=u href="#Pseudo-Terminals">Pseudo-Terminals</a>
 <br>
 
@@ -44438,24 +43450,23 @@
 <p>These functions, derived from BSD, are available in the separate
 <code>libutil</code> library, and declared in <code>pty.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>openpty</b><i> (int *<var>amaster</var>, int *<var>aslave</var>, char *<var>name</var>, struct termios *<var>termp</var>, struct winsize *<var>winp</var>)
-</i></td>
+<td align="left"><code>int <b>openpty</b><i> (int *<var>amaster</var>, int *<var>aslave</var>, char *<var>name</var>, struct termios *<var>termp</var>, struct winsize *<var>winp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function allocates and opens a pseudo-terminal pair, returning the
 file descriptor for the master in <var>*amaster</var>, and the file
 descriptor for the slave in <var>*aslave</var>.  If the argument <var>name</var>
 is not a null pointer, the file name of the slave pseudo-terminal
 device is stored in <code>*name</code>.  If <var>termp</var> is not a null pointer,
 the terminal attributes of the slave are set to the ones specified in
-the structure that <var>termp</var> points to (see <a href="#Terminal%20Modes">Terminal Modes</a>). 
+the structure that <var>termp</var> points to (see <a href="#Terminal Modes">Terminal Modes</a>). 
 Likewise, if the <var>winp</var> is not a null pointer, the screen size of
 the slave is set to the values specified in the structure that
 <var>winp</var> points to.
 
@@ -44477,21 +43488,20 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>forkpty</b><i> (int *<var>amaster</var>, char *<var>name</var>, struct termios *<var>termp</var>, struct winsize *<var>winp</var>)
-</i></td>
+<td align="left"><code>int <b>forkpty</b><i> (int *<var>amaster</var>, char *<var>name</var>, struct termios *<var>termp</var>, struct winsize *<var>winp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>openpty</code> function, but in
-addition, forks a new process (see <a href="#Creating%20a%20Process">Creating a Process</a>) and makes the
+addition, forks a new process (see <a href="#Creating a Process">Creating a Process</a>) and makes the
 newly opened slave pseudo-terminal device the controlling terminal
-(see <a href="#Controlling%20Terminal">Controlling Terminal</a>) for the child process.
+(see <a href="#Controlling Terminal">Controlling Terminal</a>) for the child process.
 
 <p>If the operation is successful, there are then both parent and child
 processes and both see <code>forkpty</code> return, but with different values:
 it returns a value of 0 in the child process and returns the child's
@@ -44508,9 +43518,9 @@
 
 <p><hr>
 Node:<a name="Syslog">Syslog</a>,
 Next:<a rel=next accesskey=n href="#Mathematics">Mathematics</a>,
-Previous:<a rel=previous accesskey=p href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>,
+Previous:<a rel=previous accesskey=p href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Syslog</h2>
@@ -44518,9 +43528,9 @@
 <p>This chapter describes facilities for issuing and logging messages of
 system administration interest.  This chapter has nothing to do with
 programs issuing messages to their own users or keeping private logs
 (One would typically do that with the facilities described in
-<a href="#I%2fO%20on%20Streams">I/O on Streams</a>).
+<a href="#I%2fO on Streams">I/O on Streams</a>).
 
 <p>Most systems have a facility called "Syslog" that allows programs to
 submit messages of interest to system administrators and can be
 configured to pass these messages on in various ways, such as printing
@@ -44529,15 +43539,15 @@
 
 <p>A program uses the facilities in this chapter to submit such messages.
 
 <ul>
-<li><a accesskey=1 href="#Overview%20of%20Syslog">Overview of Syslog</a>:            Overview of a system's Syslog facility
-<li><a accesskey=2 href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>:    Functions to submit messages to Syslog
+<li><a accesskey=1 href="#Overview of Syslog">Overview of Syslog</a>:            Overview of a system's Syslog facility
+<li><a accesskey=2 href="#Submitting Syslog Messages">Submitting Syslog Messages</a>:    Functions to submit messages to Syslog
 </ul>
 
 <p><hr>
-Node:<a name="Overview%20of%20Syslog">Overview of Syslog</a>,
-Next:<a rel=next accesskey=n href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>,
+Node:<a name="Overview of Syslog">Overview of Syslog</a>,
+Next:<a rel=next accesskey=n href="#Submitting Syslog Messages">Submitting Syslog Messages</a>,
 Up:<a rel=up accesskey=u href="#Syslog">Syslog</a>
 <br>
 
 <h3>Overview of Syslog</h3>
@@ -44594,16 +43604,16 @@
 <dt>facility
 <dd>This identifies who submitted the message.  There are a small number of
 facilities defined.  The kernel, the mail subsystem, and an FTP server
 are examples of recognized facilities.  For the complete list,
-See <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>.  Keep in mind that these are
+See <a href="#syslog%3b vsyslog">syslog; vsyslog</a>.  Keep in mind that these are
 essentially arbitrary classifications.  "Mail subsystem" doesn't have any
 more meaning than the system administrator gives to it.
 
 <br><dt>priority
 <dd>This tells how important the content of the message is.  Examples of
 defined priority values are: debug, informational, warning, critical. 
-For the complete list, See <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>.  Except for
+For the complete list, See <a href="#syslog%3b vsyslog">syslog; vsyslog</a>.  Except for
 the fact that the priorities have a defined order, the meaning of each
 of these priorities is entirely determined by the system administrator.
 
 </dl>
@@ -44619,18 +43629,18 @@
 the kernel is zero, and that makes priority and facility/priority the
 same value).
 
 <p>The GNU C library provides functions to submit messages to Syslog.  They
-do it by writing to the <code>/dev/log</code> socket.  See <a href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>.
+do it by writing to the <code>/dev/log</code> socket.  See <a href="#Submitting Syslog Messages">Submitting Syslog Messages</a>.
 
 <p>The GNU C library functions only work to submit messages to the Syslog
 facility on the same system.  To submit a message to the Syslog facility
 on another system, use the socket I/O functions to write a UDP datagram
 to the <code>syslog</code> UDP port on that system.  See <a href="#Sockets">Sockets</a>.
 
 <p><hr>
-Node:<a name="Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>,
-Previous:<a rel=previous accesskey=p href="#Overview%20of%20Syslog">Overview of Syslog</a>,
+Node:<a name="Submitting Syslog Messages">Submitting Syslog Messages</a>,
+Previous:<a rel=previous accesskey=p href="#Overview of Syslog">Overview of Syslog</a>,
 Up:<a rel=up accesskey=u href="#Syslog">Syslog</a>
 <br>
 
 <h3>Submitting Syslog Messages</h3>
@@ -44639,12 +43649,12 @@
 facility:
 
 <ul>
 <li><a accesskey=1 href="#openlog">openlog</a>:                       Open connection to Syslog
-<li><a accesskey=2 href="#syslog%3b%20vsyslog">syslog; vsyslog</a>:               Submit message to Syslog
+<li><a accesskey=2 href="#syslog%3b vsyslog">syslog; vsyslog</a>:               Submit message to Syslog
 <li><a accesskey=3 href="#closelog">closelog</a>:                      Close connection to Syslog
 <li><a accesskey=4 href="#setlogmask">setlogmask</a>:                    Cause certain messages to be ignored
-<li><a accesskey=5 href="#Syslog%20Example">Syslog Example</a>:                Example of all of the above
+<li><a accesskey=5 href="#Syslog Example">Syslog Example</a>:                Example of all of the above
 </ul>
 
 <p>These functions only work to submit messages to the Syslog facility on
 the same system.  To submit a message to the Syslog facility on another
@@ -44652,26 +43662,25 @@
 <code>syslog</code> UDP port on that system.  See <a href="#Sockets">Sockets</a>.
 
 <p><hr>
 Node:<a name="openlog">openlog</a>,
-Next:<a rel=next accesskey=n href="#syslog%3b%20vsyslog">syslog; vsyslog</a>,
-Up:<a rel=up accesskey=u href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>
+Next:<a rel=next accesskey=n href="#syslog%3b vsyslog">syslog; vsyslog</a>,
+Up:<a rel=up accesskey=u href="#Submitting Syslog Messages">Submitting Syslog Messages</a>
 <br>
 
 <h4>openlog</h4>
 
 <p>The symbols referred to in this section are declared in the file
 <code>syslog.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>openlog</b><i> (char *<var>ident</var>, int <var>option</var>,
-</i></td>
+<td align="left"><code>void <b>openlog</b><i> (char *<var>ident</var>, int <var>option</var>,</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
         int <var>facility</var>)
 
 <p><code>openlog</code> opens or reopens a connection to Syslog in preparation
@@ -44745,28 +43754,27 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="syslog%3b%20vsyslog">syslog; vsyslog</a>,
+Node:<a name="syslog%3b vsyslog">syslog; vsyslog</a>,
 Next:<a rel=next accesskey=n href="#closelog">closelog</a>,
 Previous:<a rel=previous accesskey=p href="#openlog">openlog</a>,
-Up:<a rel=up accesskey=u href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>
+Up:<a rel=up accesskey=u href="#Submitting Syslog Messages">Submitting Syslog Messages</a>
 <br>
 
 <h4>syslog, vsyslog</h4>
 
 <p>The symbols referred to in this section are declared in the file
 <code>syslog.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>syslog</b><i> (int <var>facility_priority</var>, char *<var>format</var>, ...)
-</i></td>
+<td align="left"><code>void <b>syslog</b><i> (int <var>facility_priority</var>, char *<var>format</var>, ...)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>syslog</code> submits a message to the Syslog facility.  It does this by
 writing to the Unix domain socket <code>/dev/log</code>.
@@ -44831,9 +43839,9 @@
 because any program that uses the GNU C library is not the kernel.
 
 <p>You can use just a priority code as <var>facility_priority</var>.  In that
 case, <code>syslog</code> assumes the default facility established when the
-Syslog connection was opened.  See <a href="#Syslog%20Example">Syslog Example</a>.
+Syslog connection was opened.  See <a href="#Syslog Example">Syslog Example</a>.
 
 <p>The possible values for the priority code are (macros):
 
 <dl>
@@ -44887,16 +43895,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>vsyslog</b><i> (int <var>facility_priority</var>, char *<var>format</var>, va_list arglist)
-</i></td>
+<td align="left"><code>void <b>vsyslog</b><i> (int <var>facility_priority</var>, char *<var>format</var>, va_list arglist)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This is functionally identical to <code>syslog</code>, with the BSD style variable
 length argument.
@@ -44906,26 +43913,25 @@
 
 <p><hr>
 Node:<a name="closelog">closelog</a>,
 Next:<a rel=next accesskey=n href="#setlogmask">setlogmask</a>,
-Previous:<a rel=previous accesskey=p href="#syslog%3b%20vsyslog">syslog; vsyslog</a>,
-Up:<a rel=up accesskey=u href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>
+Previous:<a rel=previous accesskey=p href="#syslog%3b vsyslog">syslog; vsyslog</a>,
+Up:<a rel=up accesskey=u href="#Submitting Syslog Messages">Submitting Syslog Messages</a>
 <br>
 
 <h4>closelog</h4>
 
 <p>The symbols referred to in this section are declared in the file
 <code>syslog.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>closelog</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>closelog</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>closelog</code> closes the current Syslog connection, if there is one. 
 This include closing the <code>dev/log</code> socket, if it is open.
@@ -44939,27 +43945,26 @@
 </table>
 
 <p><hr>
 Node:<a name="setlogmask">setlogmask</a>,
-Next:<a rel=next accesskey=n href="#Syslog%20Example">Syslog Example</a>,
+Next:<a rel=next accesskey=n href="#Syslog Example">Syslog Example</a>,
 Previous:<a rel=previous accesskey=p href="#closelog">closelog</a>,
-Up:<a rel=up accesskey=u href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>
+Up:<a rel=up accesskey=u href="#Submitting Syslog Messages">Submitting Syslog Messages</a>
 <br>
 
 <h4>setlogmask</h4>
 
 <p>The symbols referred to in this section are declared in the file
 <code>syslog.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setlogmask</b><i> (int <var>mask</var>)
-</i></td>
+<td align="left"><code>int <b>setlogmask</b><i> (int <var>mask</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>setlogmask</code> sets a mask (the "logmask") that determines which
 future <code>syslog</code> calls shall be ignored.  If a program has not
@@ -44980,9 +43985,9 @@
 <p><var>mask</var> is a bit string with one bit corresponding to each of the
 possible message priorities.  If the bit is on, <code>syslog</code> handles
 messages of that priority normally.  If it is off, <code>syslog</code>
 discards messages of that priority.  Use the message priority macros
-described in <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a> and the <code>LOG_MASK</code> to construct
+described in <a href="#syslog%3b vsyslog">syslog; vsyslog</a> and the <code>LOG_MASK</code> to construct
 an appropriate <var>mask</var> value, as in this example:
 
 <br><pre>LOG_MASK(LOG_EMERG) | LOG_MASK(LOG_ERROR)
 </pre>
@@ -45004,11 +44009,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Syslog%20Example">Syslog Example</a>,
+Node:<a name="Syslog Example">Syslog Example</a>,
 Previous:<a rel=previous accesskey=p href="#setlogmask">setlogmask</a>,
-Up:<a rel=up accesskey=u href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>
+Up:<a rel=up accesskey=u href="#Submitting Syslog Messages">Submitting Syslog Messages</a>
 <br>
 
 <h4>Syslog Example</h4>
 
@@ -45060,24 +44065,24 @@
 Not all machines have a distinct <code>long double</code> type; it may be the
 same as <code>double</code>.
 
 <ul>
-<li><a accesskey=1 href="#Mathematical%20Constants">Mathematical Constants</a>:       Precise numeric values for often-used
+<li><a accesskey=1 href="#Mathematical Constants">Mathematical Constants</a>:       Precise numeric values for often-used
                                  constants. 
-<li><a accesskey=2 href="#Trig%20Functions">Trig Functions</a>:               Sine, cosine, tangent, and friends. 
-<li><a accesskey=3 href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>:       Arcsine, arccosine, etc. 
-<li><a accesskey=4 href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>:     Also pow and sqrt. 
-<li><a accesskey=5 href="#Hyperbolic%20Functions">Hyperbolic Functions</a>:         sinh, cosh, tanh, etc. 
-<li><a accesskey=6 href="#Special%20Functions">Special Functions</a>:            Bessel, gamma, erf. 
-<li><a accesskey=7 href="#Errors%20in%20Math%20Functions">Errors in Math Functions</a>:     Known Maximum Errors in Math Functions. 
-<li><a accesskey=8 href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>:        Functions for generating pseudo-random
+<li><a accesskey=2 href="#Trig Functions">Trig Functions</a>:               Sine, cosine, tangent, and friends. 
+<li><a accesskey=3 href="#Inverse Trig Functions">Inverse Trig Functions</a>:       Arcsine, arccosine, etc. 
+<li><a accesskey=4 href="#Exponents and Logarithms">Exponents and Logarithms</a>:     Also pow and sqrt. 
+<li><a accesskey=5 href="#Hyperbolic Functions">Hyperbolic Functions</a>:         sinh, cosh, tanh, etc. 
+<li><a accesskey=6 href="#Special Functions">Special Functions</a>:            Bessel, gamma, erf. 
+<li><a accesskey=7 href="#Errors in Math Functions">Errors in Math Functions</a>:     Known Maximum Errors in Math Functions. 
+<li><a accesskey=8 href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>:        Functions for generating pseudo-random
 				 numbers. 
-<li><a accesskey=9 href="#FP%20Function%20Optimizations">FP Function Optimizations</a>:    Fast code or small code. 
+<li><a accesskey=9 href="#FP Function Optimizations">FP Function Optimizations</a>:    Fast code or small code. 
 </ul>
 
 <p><hr>
-Node:<a name="Mathematical%20Constants">Mathematical Constants</a>,
-Next:<a rel=next accesskey=n href="#Trig%20Functions">Trig Functions</a>,
+Node:<a name="Mathematical Constants">Mathematical Constants</a>,
+Next:<a rel=next accesskey=n href="#Trig Functions">Trig Functions</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Predefined Mathematical Constants</h3>
@@ -45118,9 +44123,9 @@
 <p>These constants come from the Unix98 standard and were also available in
 4.4BSD; therefore they are only defined if <code>_BSD_SOURCE</code> or
 <code>_XOPEN_SOURCE=500</code>, or a more general feature select macro, is
 defined.  The default set of features includes these constants. 
-See <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+See <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <p>All values are of type <code>double</code>.  As an extension, the GNU C
 library also defines these constants with type <code>long double</code>.  The
 <code>long double</code> macros have a lowercase <code>l</code> appended to their
@@ -45135,11 +44140,11 @@
 replace <code>PI</code> with <code>M_PI</code> throughout, or put <code>-DPI=M_PI</code>
 on the compiler command line.
 
 <p><hr>
-Node:<a name="Trig%20Functions">Trig Functions</a>,
-Next:<a rel=next accesskey=n href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Mathematical%20Constants">Mathematical Constants</a>,
+Node:<a name="Trig Functions">Trig Functions</a>,
+Next:<a rel=next accesskey=n href="#Inverse Trig Functions">Inverse Trig Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Mathematical Constants">Mathematical Constants</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Trigonometric Functions</h3>
@@ -45159,100 +44164,97 @@
 <p>You can also compute the value of pi with the expression <code>acos
 (-1.0)</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>sin</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>sin</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>sinf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>sinf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>sinl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>sinl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the sine of <var>x</var>, where <var>x</var> is given in
 radians.  The return value is in the range <code>-1</code> to <code>1</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>cos</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>cos</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>cosf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>cosf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>cosl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>cosl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the cosine of <var>x</var>, where <var>x</var> is given in
 radians.  The return value is in the range <code>-1</code> to <code>1</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>tan</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>tan</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>tanf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>tanf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>tanl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>tanl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the tangent of <var>x</var>, where <var>x</var> is given in
 radians.
 
@@ -45267,34 +44269,33 @@
 efficient to compute them simultaneously, so the library provides a
 function to do that.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>sincos</b><i> (double <var>x</var>, double *<var>sinx</var>, double *<var>cosx</var>)
-</i></td>
+<td align="left"><code>void <b>sincos</b><i> (double <var>x</var>, double *<var>sinx</var>, double *<var>cosx</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">void <b>sincosf</b><i> (float <var>x</var>, float *<var>sinx</var>, float *<var>cosx</var>)
-</i></td>
+<td align="left"><code>void <b>sincosf</b><i> (float <var>x</var>, float *<var>sinx</var>, float *<var>cosx</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">void <b>sincosl</b><i> (long double <var>x</var>, long double *<var>sinx</var>, long double *<var>cosx</var>)
-</i></td>
+<td align="left"><code>void <b>sincosl</b><i> (long double <var>x</var>, long double *<var>sinx</var>, long double *<var>cosx</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the sine of <var>x</var> in <code>*<var>sinx</var></code> and the
 cosine of <var>x</var> in <code>*<var>cos</var></code>, where <var>x</var> is given in
 radians.  Both values, <code>*<var>sinx</var></code> and <code>*<var>cosx</var></code>, are in
@@ -45312,34 +44313,33 @@
 (As of this writing GCC supports complex numbers, but there are bugs in
 the implementation.)
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>csin</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>csin</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>csinf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>csinf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>csinl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>csinl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the complex sine of <var>z</var>. 
 The mathematical definition of the complex sine is
 
@@ -45347,34 +44347,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>ccos</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>ccos</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>ccosf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>ccosf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>ccosl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>ccosl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the complex cosine of <var>z</var>. 
 The mathematical definition of the complex cosine is
 
@@ -45382,34 +44381,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>ctan</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>ctan</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>ctanf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>ctanf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>ctanl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>ctanl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the complex tangent of <var>z</var>. 
 The mathematical definition of the complex tangent is
 
@@ -45421,11 +44419,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Inverse%20Trig%20Functions">Inverse Trig Functions</a>,
-Next:<a rel=next accesskey=n href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>,
-Previous:<a rel=previous accesskey=p href="#Trig%20Functions">Trig Functions</a>,
+Node:<a name="Inverse Trig Functions">Inverse Trig Functions</a>,
+Next:<a rel=next accesskey=n href="#Exponents and Logarithms">Exponents and Logarithms</a>,
+Previous:<a rel=previous accesskey=p href="#Trig Functions">Trig Functions</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Inverse Trigonometric Functions</h3>
@@ -45434,34 +44432,33 @@
 which are the inverses of the sine, cosine and tangent functions
 respectively.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>asin</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>asin</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>asinf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>asinf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>asinl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>asinl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the arc sine of <var>x</var>--that is, the value whose
 sine is <var>x</var>.  The value is in units of radians.  Mathematically,
 there are infinitely many such values; the one actually returned is the
@@ -45473,34 +44470,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>acos</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>acos</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>acosf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>acosf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>acosl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>acosl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the arc cosine of <var>x</var>--that is, the value
 whose cosine is <var>x</var>.  The value is in units of radians. 
 Mathematically, there are infinitely many such values; the one actually
@@ -45512,34 +44508,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>atan</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>atan</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>atanf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>atanf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>atanl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>atanl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the arc tangent of <var>x</var>--that is, the value
 whose tangent is <var>x</var>.  The value is in units of radians. 
 Mathematically, there are infinitely many such values; the one actually
@@ -45547,34 +44542,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>atan2</b><i> (double <var>y</var>, double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>atan2</b><i> (double <var>y</var>, double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>atan2f</b><i> (float <var>y</var>, float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>atan2f</b><i> (float <var>y</var>, float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>atan2l</b><i> (long double <var>y</var>, long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>atan2l</b><i> (long double <var>y</var>, long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function computes the arc tangent of <var>y</var>/<var>x</var>, but the signs
 of both arguments are used to determine the quadrant of the result, and
 <var>x</var> is permitted to be zero.  The return value is given in radians
@@ -45583,43 +44577,42 @@
 <p>If <var>x</var> and <var>y</var> are coordinates of a point in the plane,
 <code>atan2</code> returns the signed angle between the line from the origin
 to that point and the x-axis.  Thus, <code>atan2</code> is useful for
 converting Cartesian coordinates to polar coordinates.  (To compute the
-radial coordinate, use <code>hypot</code>; see <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.)
+radial coordinate, use <code>hypot</code>; see <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.)
 
 <p>If both <var>x</var> and <var>y</var> are zero, <code>atan2</code> returns zero. 
 </td></tr>
 </table>
 
 <p>ISO&nbsp;C99 defines complex versions of the inverse trig functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>casin</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>casin</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>casinf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>casinf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>casinl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>casinl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the complex arc sine of <var>z</var>--that is, the
 value whose sine is <var>z</var>.  The value returned is in radians.
 
@@ -45628,34 +44621,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>cacos</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>cacos</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>cacosf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>cacosf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>cacosl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>cacosl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the complex arc cosine of <var>z</var>--that is, the
 value whose cosine is <var>z</var>.  The value returned is in radians.
 
@@ -45664,76 +44656,74 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>catan</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>catan</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>catanf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>catanf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>catanl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>catanl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the complex arc tangent of <var>z</var>--that is,
 the value whose tangent is <var>z</var>.  The value is in units of radians. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Exponents%20and%20Logarithms">Exponents and Logarithms</a>,
-Next:<a rel=next accesskey=n href="#Hyperbolic%20Functions">Hyperbolic Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>,
+Node:<a name="Exponents and Logarithms">Exponents and Logarithms</a>,
+Next:<a rel=next accesskey=n href="#Hyperbolic Functions">Hyperbolic Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Inverse Trig Functions">Inverse Trig Functions</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Exponentiation and Logarithms</h3>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>exp</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>exp</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>expf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>expf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>expl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>expl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute <code>e</code> (the base of natural logarithms) raised
 to the power <var>x</var>.
 
@@ -45742,94 +44732,92 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>exp2</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>exp2</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>exp2f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>exp2f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>exp2l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>exp2l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute <code>2</code> raised to the power <var>x</var>. 
 Mathematically, <code>exp2 (x)</code> is the same as <code>exp (x * log (2))</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>exp10</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>exp10</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>exp10f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>exp10f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>exp10l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>exp10l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">double <b>pow10</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>pow10</b><i> (double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>pow10f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>pow10f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>pow10l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>pow10l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute <code>10</code> raised to the power <var>x</var>. 
 Mathematically, <code>exp10 (x)</code> is the same as <code>exp (x * log (10))</code>.
 
@@ -45838,34 +44826,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>log</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>log</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>logf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>logf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>logl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>logl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the natural logarithm of <var>x</var>.  <code>exp (log
 (<var>x</var>))</code> equals <var>x</var>, exactly in mathematics and approximately in
 C.
@@ -45876,101 +44863,98 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>log10</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>log10</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>log10f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>log10f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>log10l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>log10l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the base-10 logarithm of <var>x</var>. 
 <code>log10 (<var>x</var>)</code> equals <code>log (<var>x</var>) / log (10)</code>.
 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>log2</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>log2</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>log2f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>log2f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>log2l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>log2l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the base-2 logarithm of <var>x</var>. 
 <code>log2 (<var>x</var>)</code> equals <code>log (<var>x</var>) / log (2)</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>logb</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>logb</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>logbf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>logbf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>logbl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>logbl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions extract the exponent of <var>x</var> and return it as a
 floating-point value.  If <code>FLT_RADIX</code> is two, <code>logb</code> is equal
 to <code>floor (log2 (x))</code>, except it's probably faster.
@@ -45982,34 +44966,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ilogb</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>ilogb</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>ilogbf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>ilogbf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>ilogbl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>ilogbl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are equivalent to the corresponding <code>logb</code>
 functions except that they return signed integer values. 
 </td></tr>
@@ -46019,16 +45002,15 @@
 returns an integer that can't be the exponent of a normal floating-point
 number.  <code>math.h</code> defines constants so you can check for this.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>FP_ILOGB0</b><i>
-</i></td>
+<td align="left"><code>int <b>FP_ILOGB0</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>ilogb</code> returns this value if its argument is <code>0</code>.  The
 numeric value is either <code>INT_MIN</code> or <code>-INT_MAX</code>.
 
@@ -46036,16 +45018,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>FP_ILOGBNAN</b><i>
-</i></td>
+<td align="left"><code>int <b>FP_ILOGBNAN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>ilogb</code> returns this value if its argument is <code>NaN</code>.  The
 numeric value is either <code>INT_MIN</code> or <code>INT_MAX</code>.
 
@@ -46075,34 +45056,33 @@
   }
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>pow</b><i> (double <var>base</var>, double <var>power</var>)
-</i></td>
+<td align="left"><code>double <b>pow</b><i> (double <var>base</var>, double <var>power</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>powf</b><i> (float <var>base</var>, float <var>power</var>)
-</i></td>
+<td align="left"><code>float <b>powf</b><i> (float <var>base</var>, float <var>power</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>powl</b><i> (long double <var>base</var>, long double <var>power</var>)
-</i></td>
+<td align="left"><code>long double <b>powl</b><i> (long double <var>base</var>, long double <var>power</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These are general exponentiation functions, returning <var>base</var> raised
 to <var>power</var>.
 
@@ -46113,34 +45093,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>sqrt</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>sqrt</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>sqrtf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>sqrtf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>sqrtl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>sqrtl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the nonnegative square root of <var>x</var>.
 
 <p>If <var>x</var> is negative, <code>sqrt</code> signals a domain error. 
@@ -46148,104 +45127,101 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>cbrt</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>cbrt</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>cbrtf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>cbrtf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>cbrtl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>cbrtl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the cube root of <var>x</var>.  They cannot
 fail; every representable real value has a representable real cube root. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>hypot</b><i> (double <var>x</var>, double <var>y</var>)
-</i></td>
+<td align="left"><code>double <b>hypot</b><i> (double <var>x</var>, double <var>y</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>hypotf</b><i> (float <var>x</var>, float <var>y</var>)
-</i></td>
+<td align="left"><code>float <b>hypotf</b><i> (float <var>x</var>, float <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>hypotl</b><i> (long double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>long double <b>hypotl</b><i> (long double <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return <code>sqrt (<var>x</var>*<var>x</var> +
 <var>y</var>*<var>y</var>)</code>.  This is the length of the hypotenuse of a right
 triangle with sides of length <var>x</var> and <var>y</var>, or the distance
 of the point (<var>x</var>, <var>y</var>) from the origin.  Using this function
 instead of the direct formula is wise, since the error is
-much smaller.  See also the function <code>cabs</code> in <a href="#Absolute%20Value">Absolute Value</a>. 
+much smaller.  See also the function <code>cabs</code> in <a href="#Absolute Value">Absolute Value</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>expm1</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>expm1</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>expm1f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>expm1f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>expm1l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>expm1l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return a value equivalent to <code>exp (<var>x</var>) - 1</code>. 
 They are computed in a way that is accurate even if <var>x</var> is
 near zero--a case where <code>exp (<var>x</var>) - 1</code> would be inaccurate owing
@@ -46253,34 +45229,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>log1p</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>log1p</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>log1pf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>log1pf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>log1pl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>log1pl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions returns a value equivalent to <code>log&nbsp;(1&nbsp;+&nbsp;<var>x</var>)</code>. 
 They are computed in a way that is accurate even if <var>x</var> is
 near zero. 
@@ -46290,34 +45265,33 @@
 <p>ISO&nbsp;C99 defines complex variants of some of the exponentiation and
 logarithm functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>cexp</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>cexp</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>cexpf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>cexpf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>cexpl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>cexpl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return <code>e</code> (the base of natural
 logarithms) raised to the power of <var>z</var>. 
 Mathematically, this corresponds to the value
@@ -46326,34 +45300,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>clog</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>clog</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>clogf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>clogf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>clogl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>clogl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the natural logarithm of <var>z</var>. 
 Mathematically, this corresponds to the value
 
@@ -46365,34 +45338,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>clog10</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>clog10</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>clog10f</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>clog10f</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>clog10l</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>clog10l</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the base 10 logarithm of the complex value
 <var>z</var>. Mathematically, this corresponds to the value
 
@@ -46402,180 +45374,175 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>csqrt</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>csqrt</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>csqrtf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>csqrtf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>csqrtl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>csqrtl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the complex square root of the argument <var>z</var>.  Unlike
 the real-valued functions, they are defined for all values of <var>z</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>cpow</b><i> (complex double <var>base</var>, complex double <var>power</var>)
-</i></td>
+<td align="left"><code>complex double <b>cpow</b><i> (complex double <var>base</var>, complex double <var>power</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>cpowf</b><i> (complex float <var>base</var>, complex float <var>power</var>)
-</i></td>
+<td align="left"><code>complex float <b>cpowf</b><i> (complex float <var>base</var>, complex float <var>power</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>cpowl</b><i> (complex long double <var>base</var>, complex long double <var>power</var>)
-</i></td>
+<td align="left"><code>complex long double <b>cpowl</b><i> (complex long double <var>base</var>, complex long double <var>power</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return <var>base</var> raised to the power of
 <var>power</var>.  This is equivalent to <code>cexp&nbsp;(y&nbsp;*&nbsp;clog&nbsp;(x))</code>
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Hyperbolic%20Functions">Hyperbolic Functions</a>,
-Next:<a rel=next accesskey=n href="#Special%20Functions">Special Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>,
+Node:<a name="Hyperbolic Functions">Hyperbolic Functions</a>,
+Next:<a rel=next accesskey=n href="#Special Functions">Special Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Exponents and Logarithms">Exponents and Logarithms</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Hyperbolic Functions</h3>
 
 <p>The functions in this section are related to the exponential functions;
-see <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+see <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>sinh</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>sinh</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>sinhf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>sinhf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>sinhl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>sinhl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the hyperbolic sine of <var>x</var>, defined
 mathematically as <code>(exp&nbsp;(<var>x</var>)&nbsp;-&nbsp;exp&nbsp;(-<var>x</var>))&nbsp;/&nbsp;2</code>.  They
 may signal overflow if <var>x</var> is too large. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>cosh</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>cosh</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>coshf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>coshf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>coshl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>coshl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These function return the hyperbolic cosine of <var>x</var>,
 defined mathematically as <code>(exp&nbsp;(<var>x</var>)&nbsp;+&nbsp;exp&nbsp;(-<var>x</var>))&nbsp;/&nbsp;2</code>. 
 They may signal overflow if <var>x</var> is too large. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>tanh</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>tanh</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>tanhf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>tanhf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>tanhl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>tanhl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the hyperbolic tangent of <var>x</var>,
 defined mathematically as <code>sinh&nbsp;(<var>x</var>)&nbsp;/&nbsp;cosh&nbsp;(<var>x</var>)</code>. 
 They may signal overflow if <var>x</var> is too large. 
@@ -46585,200 +45552,194 @@
 <p>There are counterparts for the hyperbolic functions which take
 complex arguments.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>csinh</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>csinh</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>csinhf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>csinhf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>csinhl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>csinhl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the complex hyperbolic sine of <var>z</var>, defined
 mathematically as <code>(exp&nbsp;(<var>z</var>)&nbsp;-&nbsp;exp&nbsp;(-<var>z</var>))&nbsp;/&nbsp;2</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>ccosh</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>ccosh</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>ccoshf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>ccoshf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>ccoshl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>ccoshl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the complex hyperbolic cosine of <var>z</var>, defined
 mathematically as <code>(exp&nbsp;(<var>z</var>)&nbsp;+&nbsp;exp&nbsp;(-<var>z</var>))&nbsp;/&nbsp;2</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>ctanh</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>ctanh</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>ctanhf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>ctanhf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>ctanhl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>ctanhl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the complex hyperbolic tangent of <var>z</var>,
 defined mathematically as <code>csinh&nbsp;(<var>z</var>)&nbsp;/&nbsp;ccosh&nbsp;(<var>z</var>)</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>asinh</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>asinh</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>asinhf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>asinhf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>asinhl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>asinhl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the inverse hyperbolic sine of <var>x</var>--the
 value whose hyperbolic sine is <var>x</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>acosh</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>acosh</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>acoshf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>acoshf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>acoshl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>acoshl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the inverse hyperbolic cosine of <var>x</var>--the
 value whose hyperbolic cosine is <var>x</var>.  If <var>x</var> is less than
 <code>1</code>, <code>acosh</code> signals a domain error. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>atanh</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>atanh</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>atanhf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>atanhf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>atanhl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>atanhl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the inverse hyperbolic tangent of <var>x</var>--the
 value whose hyperbolic tangent is <var>x</var>.  If the absolute value of
 <var>x</var> is greater than <code>1</code>, <code>atanh</code> signals a domain error;
@@ -46786,101 +45747,98 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>casinh</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>casinh</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>casinhf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>casinhf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>casinhl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>casinhl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the inverse complex hyperbolic sine of
 <var>z</var>--the value whose complex hyperbolic sine is <var>z</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>cacosh</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>cacosh</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>cacoshf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>cacoshf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>cacoshl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>cacoshl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the inverse complex hyperbolic cosine of
 <var>z</var>--the value whose complex hyperbolic cosine is <var>z</var>.  Unlike
 the real-valued functions, there are no restrictions on the value of <var>z</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>catanh</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>catanh</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>catanhf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>catanhf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>catanhl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>catanhl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the inverse complex hyperbolic tangent of
 <var>z</var>--the value whose complex hyperbolic tangent is <var>z</var>.  Unlike
 the real-valued functions, there are no restrictions on the value of
@@ -46888,11 +45846,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Special%20Functions">Special Functions</a>,
-Next:<a rel=next accesskey=n href="#Errors%20in%20Math%20Functions">Errors in Math Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Hyperbolic%20Functions">Hyperbolic Functions</a>,
+Node:<a name="Special Functions">Special Functions</a>,
+Next:<a rel=next accesskey=n href="#Errors in Math Functions">Errors in Math Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Hyperbolic Functions">Hyperbolic Functions</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Special Functions</h3>
@@ -46900,34 +45858,33 @@
 <p>These are some more exotic mathematical functions which are sometimes
 useful.  Currently they only have real-valued versions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>erf</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>erf</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>erff</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>erff</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>erfl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>erfl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>erf</code> returns the error function of <var>x</var>.  The error
 function is defined as
 <br><pre>erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt
@@ -46935,67 +45892,65 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>erfc</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>erfc</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>erfcf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>erfcf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>erfcl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>erfcl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>erfc</code> returns <code>1.0 - erf(<var>x</var>)</code>, but computed in a
 fashion that avoids round-off error when <var>x</var> is large. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>lgamma</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>lgamma</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>lgammaf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>lgammaf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>lgammal</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>lgammal</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>lgamma</code> returns the natural logarithm of the absolute value of
 the gamma function of <var>x</var>.  The gamma function is defined as
 <br><pre>gamma (x) = integral from 0 to &amp;infin; of t^(x-1) e^-t dt
@@ -47018,68 +45973,66 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>lgamma_r</b><i> (double <var>x</var>, int *<var>signp</var>)
-</i></td>
+<td align="left"><code>double <b>lgamma_r</b><i> (double <var>x</var>, int *<var>signp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>lgammaf_r</b><i> (float <var>x</var>, int *<var>signp</var>)
-</i></td>
+<td align="left"><code>float <b>lgammaf_r</b><i> (float <var>x</var>, int *<var>signp</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>lgammal_r</b><i> (long double <var>x</var>, int *<var>signp</var>)
-</i></td>
+<td align="left"><code>long double <b>lgammal_r</b><i> (long double <var>x</var>, int *<var>signp</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>lgamma_r</code> is just like <code>lgamma</code>, but it stores the sign of
 the intermediate result in the variable pointed to by <var>signp</var>
 instead of in the <var>signgam</var> global.  This means it is reentrant. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>gamma</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>gamma</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>gammaf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>gammaf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>gammal</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>gammal</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions exist for compatibility reasons.  They are equivalent to
 <code>lgamma</code> etc.  It is better to use <code>lgamma</code> since for one the
 name reflects better the actual computation, moreover <code>lgamma</code> is
@@ -47087,34 +46040,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>tgamma</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>tgamma</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>tgammaf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>tgammaf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>tgammal</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>tgammal</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>tgamma</code> applies the gamma function to <var>x</var>.  The gamma
 function is defined as
 <br><pre>gamma (x) = integral from 0 to &amp;infin; of t^(x-1) e^-t dt
@@ -47124,133 +46076,129 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>j0</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>j0</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>j0f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>j0f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>j0l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>j0l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>j0</code> returns the Bessel function of the first kind of order 0 of
 <var>x</var>.  It may signal underflow if <var>x</var> is too large. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>j1</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>j1</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>j1f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>j1f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>j1l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>j1l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>j1</code> returns the Bessel function of the first kind of order 1 of
 <var>x</var>.  It may signal underflow if <var>x</var> is too large. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>jn</b><i> (int n, double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>jn</b><i> (int n, double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>jnf</b><i> (int n, float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>jnf</b><i> (int n, float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>jnl</b><i> (int n, long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>jnl</b><i> (int n, long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>jn</code> returns the Bessel function of the first kind of order
 <var>n</var> of <var>x</var>.  It may signal underflow if <var>x</var> is too large. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>y0</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>y0</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>y0f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>y0f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>y0l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>y0l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>y0</code> returns the Bessel function of the second kind of order 0 of
 <var>x</var>.  It may signal underflow if <var>x</var> is too large.  If <var>x</var>
 is negative, <code>y0</code> signals a domain error; if it is zero,
@@ -47258,34 +46206,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>y1</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>y1</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>y1f</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>y1f</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>y1l</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>y1l</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>y1</code> returns the Bessel function of the second kind of order 1 of
 <var>x</var>.  It may signal underflow if <var>x</var> is too large.  If <var>x</var>
 is negative, <code>y1</code> signals a domain error; if it is zero,
@@ -47293,34 +46240,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>yn</b><i> (int n, double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>yn</b><i> (int n, double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>ynf</b><i> (int n, float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>ynf</b><i> (int n, float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>ynl</b><i> (int n, long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>ynl</b><i> (int n, long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>yn</code> returns the Bessel function of the second kind of order <var>n</var> of
 <var>x</var>.  It may signal underflow if <var>x</var> is too large.  If <var>x</var>
 is negative, <code>yn</code> signals a domain error; if it is zero,
@@ -47328,11 +46274,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Errors%20in%20Math%20Functions">Errors in Math Functions</a>,
-Next:<a rel=next accesskey=n href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>,
-Previous:<a rel=previous accesskey=p href="#Special%20Functions">Special Functions</a>,
+Node:<a name="Errors in Math Functions">Errors in Math Functions</a>,
+Next:<a rel=next accesskey=n href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>,
+Previous:<a rel=previous accesskey=p href="#Special Functions">Special Functions</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Known Maximum Errors in Math Functions</h3>
@@ -48163,11 +47109,11 @@
 <br></td></tr><tr align="left"><td valign="top">ynl  </td><td valign="top">- </td><td valign="top">- </td><td valign="top">7
 <br></td></tr></table>
 
 <p><hr>
-Node:<a name="Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>,
-Next:<a rel=next accesskey=n href="#FP%20Function%20Optimizations">FP Function Optimizations</a>,
-Previous:<a rel=previous accesskey=p href="#Errors%20in%20Math%20Functions">Errors in Math Functions</a>,
+Node:<a name="Pseudo-Random Numbers">Pseudo-Random Numbers</a>,
+Next:<a rel=next accesskey=n href="#FP Function Optimizations">FP Function Optimizations</a>,
+Previous:<a rel=previous accesskey=p href="#Errors in Math Functions">Errors in Math Functions</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Pseudo-Random Numbers</h3>
@@ -48205,17 +47151,17 @@
 by the XPG standard and therefore will be present in all modern Unix
 systems.
 
 <ul>
-<li><a accesskey=1 href="#ISO%20Random">ISO Random</a>:                   <code>rand</code> and friends. 
-<li><a accesskey=2 href="#BSD%20Random">BSD Random</a>:                   <code>random</code> and friends. 
-<li><a accesskey=3 href="#SVID%20Random">SVID Random</a>:                  <code>drand48</code> and friends. 
+<li><a accesskey=1 href="#ISO Random">ISO Random</a>:                   <code>rand</code> and friends. 
+<li><a accesskey=2 href="#BSD Random">BSD Random</a>:                   <code>random</code> and friends. 
+<li><a accesskey=3 href="#SVID Random">SVID Random</a>:                  <code>drand48</code> and friends. 
 </ul>
 
 <p><hr>
-Node:<a name="ISO%20Random">ISO Random</a>,
-Next:<a rel=next accesskey=n href="#BSD%20Random">BSD Random</a>,
-Up:<a rel=up accesskey=u href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>
+Node:<a name="ISO Random">ISO Random</a>,
+Next:<a rel=next accesskey=n href="#BSD Random">BSD Random</a>,
+Up:<a rel=up accesskey=u href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>
 <br>
 
 <h4>ISO C Random Number Functions</h4>
 
@@ -48225,16 +47171,15 @@
 <p>To use these facilities, you should include the header file
 <code>stdlib.h</code> in your program.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>RAND_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>RAND_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant representing the largest
 value the <code>rand</code> function can return.  In the GNU library, it is
 <code>2147483647</code>, which is the largest signed integer representable in
@@ -48242,31 +47187,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>rand</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>rand</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>rand</code> function returns the next pseudo-random number in the
 series.  The value ranges from <code>0</code> to <code>RAND_MAX</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>srand</b><i> (unsigned int <var>seed</var>)
-</i></td>
+<td align="left"><code>void <b>srand</b><i> (unsigned int <var>seed</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function establishes <var>seed</var> as the seed for a new series of
 pseudo-random numbers.  If you call <code>rand</code> before a seed has been
 established with <code>srand</code>, it uses the value <code>1</code> as a default
@@ -48281,16 +47224,15 @@
 numbers in multi-threaded programs.  However, the extension is badly
 designed and unsuitable for serious work.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>rand_r</b><i> (unsigned int *<var>seed</var>)
-</i></td>
+<td align="left"><code>int <b>rand_r</b><i> (unsigned int *<var>seed</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a random number in the range 0 to <code>RAND_MAX</code>
 just as <code>rand</code> does.  However, all its state is stored in the
 <var>seed</var> argument.  This means the RNG's state can only have as many
@@ -48304,12 +47246,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="BSD%20Random">BSD Random</a>,
-Next:<a rel=next accesskey=n href="#SVID%20Random">SVID Random</a>,
-Previous:<a rel=previous accesskey=p href="#ISO%20Random">ISO Random</a>,
-Up:<a rel=up accesskey=u href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>
+Node:<a name="BSD Random">BSD Random</a>,
+Next:<a rel=next accesskey=n href="#SVID Random">SVID Random</a>,
+Previous:<a rel=previous accesskey=p href="#ISO Random">ISO Random</a>,
+Up:<a rel=up accesskey=u href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>
 <br>
 
 <h4>BSD Random Number Functions</h4>
 
@@ -48319,16 +47261,15 @@
 
 <p>The prototypes for these functions are in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>random</b><i> (void)
-</i></td>
+<td align="left"><code>long int <b>random</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next pseudo-random number in the sequence. 
 The value returned ranges from <code>0</code> to <code>RAND_MAX</code>.
 
@@ -48340,16 +47281,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>srandom</b><i> (unsigned int <var>seed</var>)
-</i></td>
+<td align="left"><code>void <b>srandom</b><i> (unsigned int <var>seed</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>srandom</code> function sets the state of the random number
 generator based on the integer <var>seed</var>.  If you supply a <var>seed</var> value
 of <code>1</code>, this will cause <code>random</code> to reproduce the default set
@@ -48360,16 +47300,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>initstate</b><i> (unsigned int <var>seed</var>, void *<var>state</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>void * <b>initstate</b><i> (unsigned int <var>seed</var>, void *<var>state</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>initstate</code> function is used to initialize the random number
 generator state.  The argument <var>state</var> is an array of <var>size</var>
 bytes, used to hold the state information.  It is initialized based on
@@ -48382,16 +47321,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>setstate</b><i> (void *<var>state</var>)
-</i></td>
+<td align="left"><code>void * <b>setstate</b><i> (void *<var>state</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>setstate</code> function restores the random number state
 information <var>state</var>.  The argument must have been the result of
 a previous call to <var>initstate</var> or <var>setstate</var>.
@@ -48418,16 +47356,15 @@
 
 <p>The <code>stdlib.h</code> header contains a definition of the following type:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct random_data</b><i>
-</i></td>
+<td align="left"><code><b>struct random_data</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>Objects of type <code>struct random_data</code> contain the information
 necessary to represent the state of the PRNG.  Although a complete
@@ -48438,75 +47375,71 @@
 <p>The functions modifying the state follow exactly the already described
 functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>random_r</b><i> (struct random_data *restrict <var>buf</var>, int32_t *restrict <var>result</var>)
-</i></td>
+<td align="left"><code>int <b>random_r</b><i> (struct random_data *restrict <var>buf</var>, int32_t *restrict <var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>random_r</code> function behaves exactly like the <code>random</code>
 function except that it uses and modifies the state in the object
 pointed to by the first parameter instead of the global state. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>srandom_r</b><i> (unsigned int <var>seed</var>, struct random_data *<var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>srandom_r</b><i> (unsigned int <var>seed</var>, struct random_data *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>srandom_r</code> function behaves exactly like the <code>srandom</code>
 function except that it uses and modifies the state in the object
 pointed to by the second parameter instead of the global state. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>initstate_r</b><i> (unsigned int <var>seed</var>, char *restrict <var>statebuf</var>, size_t <var>statelen</var>, struct random_data *restrict <var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>initstate_r</b><i> (unsigned int <var>seed</var>, char *restrict <var>statebuf</var>, size_t <var>statelen</var>, struct random_data *restrict <var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>initstate_r</code> function behaves exactly like the <code>initstate</code>
 function except that it uses and modifies the state in the object
 pointed to by the fourth parameter instead of the global state. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setstate_r</b><i> (char *restrict <var>statebuf</var>, struct random_data *restrict <var>buf</var>)
-</i></td>
+<td align="left"><code>int <b>setstate_r</b><i> (char *restrict <var>statebuf</var>, struct random_data *restrict <var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>setstate_r</code> function behaves exactly like the <code>setstate</code>
 function except that it uses and modifies the state in the object
 pointed to by the first parameter instead of the global state. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="SVID%20Random">SVID Random</a>,
-Previous:<a rel=previous accesskey=p href="#BSD%20Random">BSD Random</a>,
-Up:<a rel=up accesskey=u href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>
+Node:<a name="SVID Random">SVID Random</a>,
+Previous:<a rel=previous accesskey=p href="#BSD Random">BSD Random</a>,
+Up:<a rel=up accesskey=u href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>
 <br>
 
 <h4>SVID Random Number Function</h4>
 
@@ -48539,16 +47472,15 @@
 
 <p>The prototypes for these functions are in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>drand48</b><i> (void)
-</i></td>
+<td align="left"><code>double <b>drand48</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a <code>double</code> value in the range of <code>0.0</code>
 to <code>1.0</code> (exclusive).  The random bits are determined by the global
 state of the random number generator in the C library.
@@ -48560,16 +47492,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>erand48</b><i> (unsigned short int <var>xsubi</var>[3])
-</i></td>
+<td align="left"><code>double <b>erand48</b><i> (unsigned short int <var>xsubi</var>[3])</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a <code>double</code> value in the range of <code>0.0</code>
 to <code>1.0</code> (exclusive), similarly to <code>drand48</code>.  The argument is
 an array describing the state of the random number generator.
@@ -48580,16 +47511,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>lrand48</b><i> (void)
-</i></td>
+<td align="left"><code>long int <b>lrand48</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lrand48</code> function returns an integer value in the range of
 <code>0</code> to <code>2^31</code> (exclusive).  Even if the size of the <code>long
 int</code> type can take more than 32 bits, no higher numbers are returned. 
@@ -48598,16 +47528,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>nrand48</b><i> (unsigned short int <var>xsubi</var>[3])
-</i></td>
+<td align="left"><code>long int <b>nrand48</b><i> (unsigned short int <var>xsubi</var>[3])</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>lrand48</code> function in that it
 returns a number in the range of <code>0</code> to <code>2^31</code> (exclusive) but
 the state of the random number generator used to produce the random bits
@@ -48620,32 +47549,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>mrand48</b><i> (void)
-</i></td>
+<td align="left"><code>long int <b>mrand48</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mrand48</code> function is similar to <code>lrand48</code>.  The only
 difference is that the numbers returned are in the range <code>-2^31</code> to
 <code>2^31</code> (exclusive). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>jrand48</b><i> (unsigned short int <var>xsubi</var>[3])
-</i></td>
+<td align="left"><code>long int <b>jrand48</b><i> (unsigned short int <var>xsubi</var>[3])</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>jrand48</code> function is similar to <code>nrand48</code>.  The only
 difference is that the numbers returned are in the range <code>-2^31</code> to
 <code>2^31</code> (exclusive).  For the <code>xsubi</code> parameter the same
@@ -48657,16 +47584,15 @@
 several ways.  The methods differ in the completeness of the
 information provided.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>srand48</b><i> (long int <var>seedval</var>)
-</i></td>
+<td align="left"><code>void <b>srand48</b><i> (long int <var>seedval</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>srand48</code> function sets the most significant 32 bits of the
 internal state of the random number generator to the least
 significant 32 bits of the <var>seedval</var> parameter.  The lower 16 bits
@@ -48684,16 +47610,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned short int * <b>seed48</b><i> (unsigned short int <var>seed16v</var>[3])
-</i></td>
+<td align="left"><code>unsigned short int * <b>seed48</b><i> (unsigned short int <var>seed16v</var>[3])</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>seed48</code> function initializes all 48 bits of the state of the
 internal random number generator from the contents of the parameter
 <var>seed16v</var>.  Here the lower 16 bits of the first element of
@@ -48719,16 +47644,15 @@
 which enables you to specify even more information by allowing you to
 change the parameters in the congruential formula.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>lcong48</b><i> (unsigned short int <var>param</var>[7])
-</i></td>
+<td align="left"><code>void <b>lcong48</b><i> (unsigned short int <var>param</var>[7])</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lcong48</code> function allows the user to change the complete state
 of the random number generator.  Unlike <code>srand48</code> and
 <code>seed48</code>, this function also changes the constants in the
@@ -48759,16 +47683,15 @@
 <p>The user-supplied buffer must be of type <code>struct drand48_data</code>. 
 This type should be regarded as opaque and not manipulated directly.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>drand48_r</b><i> (struct drand48_data *<var>buffer</var>, double *<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>drand48_r</b><i> (struct drand48_data *<var>buffer</var>, double *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is equivalent to the <code>drand48</code> function with the
 difference that it does not modify the global random number generator
 parameters but instead the parameters in the buffer supplied through the
@@ -48784,16 +47707,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>erand48_r</b><i> (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, double *<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>erand48_r</b><i> (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, double *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>erand48_r</code> function works like <code>erand48</code>, but in addition
 it takes an argument <var>buffer</var> which describes the random number
 generator.  The state of the random number generator is taken from the
@@ -48808,16 +47730,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>lrand48_r</b><i> (struct drand48_data *<var>buffer</var>, double *<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>lrand48_r</b><i> (struct drand48_data *<var>buffer</var>, double *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>lrand48</code>, but in addition it takes a
 pointer to a buffer describing the state of the random number generator
 just like <code>drand48</code>.
@@ -48830,16 +47751,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>nrand48_r</b><i> (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, long int *<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>nrand48_r</b><i> (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, long int *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>nrand48_r</code> function works like <code>nrand48</code> in that it
 produces a random number in the range <code>0</code> to <code>2^31</code>.  But instead
 of using the global parameters for the congruential formula it uses the
@@ -48854,16 +47774,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mrand48_r</b><i> (struct drand48_data *<var>buffer</var>, double *<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>mrand48_r</b><i> (struct drand48_data *<var>buffer</var>, double *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>mrand48</code> but like the other reentrant
 functions it uses the random number generator described by the value in
 the buffer pointed to by <var>buffer</var>.
@@ -48876,16 +47795,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>jrand48_r</b><i> (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, long int *<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>jrand48_r</b><i> (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, long int *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>jrand48_r</code> function is similar to <code>jrand48</code>.  Like the
 other reentrant functions of this function family it uses the
 congruential formula parameters from the buffer pointed to by
@@ -48916,16 +47834,15 @@
 recommended to use these functions since the result might not always be
 what you expect.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>srand48_r</b><i> (long int <var>seedval</var>, struct drand48_data *<var>buffer</var>)
-</i></td>
+<td align="left"><code>int <b>srand48_r</b><i> (long int <var>seedval</var>, struct drand48_data *<var>buffer</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The description of the random number generator represented by the
 information in <var>buffer</var> is initialized similarly to what the function
 <code>srand48</code> does.  The state is initialized from the parameter
@@ -48939,16 +47856,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>seed48_r</b><i> (unsigned short int <var>seed16v</var>[3], struct drand48_data *<var>buffer</var>)
-</i></td>
+<td align="left"><code>int <b>seed48_r</b><i> (unsigned short int <var>seed16v</var>[3], struct drand48_data *<var>buffer</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>srand48_r</code> but like <code>seed48</code> it
 initializes all 48 bits of the state from the parameter <var>seed16v</var>.
 
@@ -48963,16 +47879,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>lcong48_r</b><i> (unsigned short int <var>param</var>[7], struct drand48_data *<var>buffer</var>)
-</i></td>
+<td align="left"><code>int <b>lcong48_r</b><i> (unsigned short int <var>param</var>[7], struct drand48_data *<var>buffer</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function initializes all aspects of the random number generator
 described in <var>buffer</var> with the data in <var>param</var>.  Here it is
 especially true that the function does more than just copying the
@@ -48987,10 +47902,10 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="FP%20Function%20Optimizations">FP Function Optimizations</a>,
-Previous:<a rel=previous accesskey=p href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>,
+Node:<a name="FP Function Optimizations">FP Function Optimizations</a>,
+Previous:<a rel=previous accesskey=p href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>,
 Up:<a rel=up accesskey=u href="#Mathematics">Mathematics</a>
 <br>
 
 <h3>Is Fast Code or Small Code preferred?</h3>
@@ -49030,9 +47945,9 @@
 the FPU to run un-pipelined, which can more than double calculation time.
 
 <p><hr>
 Node:<a name="Arithmetic">Arithmetic</a>,
-Next:<a rel=next accesskey=n href="#Date%20and%20Time">Date and Time</a>,
+Next:<a rel=next accesskey=n href="#Date and Time">Date and Time</a>,
 Previous:<a rel=previous accesskey=p href="#Mathematics">Mathematics</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -49045,24 +47960,24 @@
 <code>complex.h</code>.
 
 <ul>
 <li><a accesskey=1 href="#Integers">Integers</a>:                     Basic integer types and concepts
-<li><a accesskey=2 href="#Integer%20Division">Integer Division</a>:             Integer division with guaranteed rounding. 
-<li><a accesskey=3 href="#Floating%20Point%20Numbers">Floating Point Numbers</a>:       Basic concepts.  IEEE 754. 
-<li><a accesskey=4 href="#Floating%20Point%20Classes">Floating Point Classes</a>:       The five kinds of floating-point number. 
-<li><a accesskey=5 href="#Floating%20Point%20Errors">Floating Point Errors</a>:        When something goes wrong in a calculation. 
+<li><a accesskey=2 href="#Integer Division">Integer Division</a>:             Integer division with guaranteed rounding. 
+<li><a accesskey=3 href="#Floating Point Numbers">Floating Point Numbers</a>:       Basic concepts.  IEEE 754. 
+<li><a accesskey=4 href="#Floating Point Classes">Floating Point Classes</a>:       The five kinds of floating-point number. 
+<li><a accesskey=5 href="#Floating Point Errors">Floating Point Errors</a>:        When something goes wrong in a calculation. 
 <li><a accesskey=6 href="#Rounding">Rounding</a>:                     Controlling how results are rounded. 
-<li><a accesskey=7 href="#Control%20Functions">Control Functions</a>:            Saving and restoring the FPU's state. 
-<li><a accesskey=8 href="#Arithmetic%20Functions">Arithmetic Functions</a>:         Fundamental operations provided by the library. 
-<li><a accesskey=9 href="#Complex%20Numbers">Complex Numbers</a>:              The types.  Writing complex constants. 
-<li><a href="#Operations%20on%20Complex">Operations on Complex</a>:        Projection, conjugation, decomposition. 
-<li><a href="#Parsing%20of%20Numbers">Parsing of Numbers</a>:           Converting strings to numbers. 
-<li><a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>:   An archaic way to convert numbers to strings. 
+<li><a accesskey=7 href="#Control Functions">Control Functions</a>:            Saving and restoring the FPU's state. 
+<li><a accesskey=8 href="#Arithmetic Functions">Arithmetic Functions</a>:         Fundamental operations provided by the library. 
+<li><a accesskey=9 href="#Complex Numbers">Complex Numbers</a>:              The types.  Writing complex constants. 
+<li><a href="#Operations on Complex">Operations on Complex</a>:        Projection, conjugation, decomposition. 
+<li><a href="#Parsing of Numbers">Parsing of Numbers</a>:           Converting strings to numbers. 
+<li><a href="#System V Number Conversion">System V Number Conversion</a>:   An archaic way to convert numbers to strings. 
 </ul>
 
 <p><hr>
 Node:<a name="Integers">Integers</a>,
-Next:<a rel=next accesskey=n href="#Integer%20Division">Integer Division</a>,
+Next:<a rel=next accesskey=n href="#Integer Division">Integer Division</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Integers</h3>
@@ -49150,16 +48065,16 @@
 <code>INTMAX_MAX</code>, <code>INTMAX_MIN</code>.  Note that there are no macros for
 unsigned integer minima.  These are always zero.
 
 <p>There are similar macros for use with C's built in integer types which
-should come with your C compiler.  These are described in <a href="#Data%20Type%20Measurements">Data Type Measurements</a>.
+should come with your C compiler.  These are described in <a href="#Data Type Measurements">Data Type Measurements</a>.
 
 <p>Don't forget you can use the C <code>sizeof</code> function with any of these
 data types to get the number of bytes of storage each uses.
 
 <p><hr>
-Node:<a name="Integer%20Division">Integer Division</a>,
-Next:<a rel=next accesskey=n href="#Floating%20Point%20Numbers">Floating Point Numbers</a>,
+Node:<a name="Integer Division">Integer Division</a>,
+Next:<a rel=next accesskey=n href="#Floating Point Numbers">Floating Point Numbers</a>,
 Previous:<a rel=previous accesskey=p href="#Integers">Integers</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
@@ -49180,16 +48095,15 @@
 <p>To use these facilities, you should include the header file
 <code>stdlib.h</code> in your program.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>div_t</b><i>
-</i></td>
+<td align="left"><code><b>div_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a structure type used to hold the result returned by the <code>div</code>
 function.  It has the following members:
 
@@ -49203,16 +48117,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">div_t <b>div</b><i> (int <var>numerator</var>, int <var>denominator</var>)
-</i></td>
+<td align="left"><code>div_t <b>div</b><i> (int <var>numerator</var>, int <var>denominator</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function <code>div</code> computes the quotient and remainder from
 the division of <var>numerator</var> by <var>denominator</var>, returning the
 result in a structure of type <code>div_t</code>.
@@ -49230,16 +48143,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>ldiv_t</b><i>
-</i></td>
+<td align="left"><code><b>ldiv_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a structure type used to hold the result returned by the <code>ldiv</code>
 function.  It has the following members:
 
@@ -49256,32 +48168,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">ldiv_t <b>ldiv</b><i> (long int <var>numerator</var>, long int <var>denominator</var>)
-</i></td>
+<td align="left"><code>ldiv_t <b>ldiv</b><i> (long int <var>numerator</var>, long int <var>denominator</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ldiv</code> function is similar to <code>div</code>, except that the
 arguments are of type <code>long int</code> and the result is returned as a
 structure of type <code>ldiv_t</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>lldiv_t</b><i>
-</i></td>
+<td align="left"><code><b>lldiv_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a structure type used to hold the result returned by the <code>lldiv</code>
 function.  It has the following members:
 
@@ -49298,16 +48208,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">lldiv_t <b>lldiv</b><i> (long long int <var>numerator</var>, long long int <var>denominator</var>)
-</i></td>
+<td align="left"><code>lldiv_t <b>lldiv</b><i> (long long int <var>numerator</var>, long long int <var>denominator</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>lldiv</code> function is like the <code>div</code> function, but the
 arguments are of type <code>long long int</code> and the result is returned as
 a structure of type <code>lldiv_t</code>.
@@ -49316,16 +48225,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>imaxdiv_t</b><i>
-</i></td>
+<td align="left"><code><b>imaxdiv_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a structure type used to hold the result returned by the <code>imaxdiv</code>
 function.  It has the following members:
 
@@ -49345,16 +48253,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">imaxdiv_t <b>imaxdiv</b><i> (intmax_t <var>numerator</var>, intmax_t <var>denominator</var>)
-</i></td>
+<td align="left"><code>imaxdiv_t <b>imaxdiv</b><i> (intmax_t <var>numerator</var>, intmax_t <var>denominator</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>imaxdiv</code> function is like the <code>div</code> function, but the
 arguments are of type <code>intmax_t</code> and the result is returned as
 a structure of type <code>imaxdiv_t</code>.
@@ -49365,11 +48272,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Floating%20Point%20Numbers">Floating Point Numbers</a>,
-Next:<a rel=next accesskey=n href="#Floating%20Point%20Classes">Floating Point Classes</a>,
-Previous:<a rel=previous accesskey=p href="#Integer%20Division">Integer Division</a>,
+Node:<a name="Floating Point Numbers">Floating Point Numbers</a>,
+Next:<a rel=next accesskey=n href="#Floating Point Classes">Floating Point Classes</a>,
+Previous:<a rel=previous accesskey=p href="#Integer Division">Integer Division</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Floating Point Numbers</h3>
@@ -49380,9 +48287,9 @@
 <dfn>mantissa</dfn>, the <dfn>exponent</dfn>, and the <dfn>sign bit</dfn>.  The real
 number represented by a floating-point value is given by
 (s ? -1 : 1) &amp;middot; 2^e &amp;middot; M
 where s is the sign bit, e the exponent, and M
-the mantissa.  See <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>, for details.  (It is
+the mantissa.  See <a href="#Floating Point Concepts">Floating Point Concepts</a>, for details.  (It is
 possible to have a different <dfn>base</dfn> for the exponent, but all modern
 hardware uses 2.)
 
 <p>Floating-point numbers can represent a finite subset of the real
@@ -49403,11 +48310,11 @@
 result could not be represented, and the special values <dfn>infinity</dfn>
 and <dfn>not a number</dfn> (NaN).
 
 <p><hr>
-Node:<a name="Floating%20Point%20Classes">Floating Point Classes</a>,
-Next:<a rel=next accesskey=n href="#Floating%20Point%20Errors">Floating Point Errors</a>,
-Previous:<a rel=previous accesskey=p href="#Floating%20Point%20Numbers">Floating Point Numbers</a>,
+Node:<a name="Floating Point Classes">Floating Point Classes</a>,
+Next:<a rel=next accesskey=n href="#Floating Point Errors">Floating Point Errors</a>,
+Previous:<a rel=previous accesskey=p href="#Floating Point Numbers">Floating Point Numbers</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Floating-Point Number Classification Functions</h3>
@@ -49415,32 +48322,31 @@
 <p>ISO&nbsp;C99 defines macros that let you determine what sort of
 floating-point number a variable holds.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fpclassify</b><i> (<em>float-type</em> <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>fpclassify</b><i> (<em>float-type</em> <var>x</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a generic macro which works on all floating-point types and
 which returns a value of type <code>int</code>.  The possible values are:
 
 <dl>
 <dt><code>FP_NAN</code>
-<dd>The floating-point number <var>x</var> is "Not a Number" (see <a href="#Infinity%20and%20NaN">Infinity and NaN</a>)
+<dd>The floating-point number <var>x</var> is "Not a Number" (see <a href="#Infinity and NaN">Infinity and NaN</a>)
 <br><dt><code>FP_INFINITE</code>
-<dd>The value of <var>x</var> is either plus or minus infinity (see <a href="#Infinity%20and%20NaN">Infinity and NaN</a>)
+<dd>The value of <var>x</var> is either plus or minus infinity (see <a href="#Infinity and NaN">Infinity and NaN</a>)
 <br><dt><code>FP_ZERO</code>
 <dd>The value of <var>x</var> is zero.  In floating-point formats like IEEE&nbsp;754, where zero can be signed, this value is also returned if
 <var>x</var> is negative zero. 
 <br><dt><code>FP_SUBNORMAL</code>
 <dd>Numbers whose absolute value is too small to be represented in the
 normal format are represented in an alternate, <dfn>denormalized</dfn> format
-(see <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>).  This format is less precise but can
+(see <a href="#Floating Point Concepts">Floating Point Concepts</a>).  This format is less precise but can
 represent values closer to zero.  <code>fpclassify</code> returns this value
 for values of <var>x</var> in this alternate format. 
 <br><dt><code>FP_NORMAL</code>
 <dd>This value is returned for all other values of <var>x</var>.  It indicates
@@ -49456,16 +48362,15 @@
 <code>fpclassify</code>, since there is special hardware support for them. 
 You should therefore use the specific macros whenever possible.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isfinite</b><i> (<em>float-type</em> <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isfinite</b><i> (<em>float-type</em> <var>x</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value if <var>x</var> is finite: not plus or
 minus infinity, and not NaN.  It is equivalent to
 
@@ -49477,16 +48382,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isnormal</b><i> (<em>float-type</em> <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isnormal</b><i> (<em>float-type</em> <var>x</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value if <var>x</var> is finite and normalized. 
 It is equivalent to
 
@@ -49495,16 +48399,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isnan</b><i> (<em>float-type</em> <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isnan</b><i> (<em>float-type</em> <var>x</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value if <var>x</var> is NaN.  It is equivalent
 to
 
@@ -49519,67 +48422,65 @@
 and will be available more widely.  Also, since they are macros, you do
 not have to worry about the type of their argument.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isinf</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isinf</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>isinff</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isinff</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>isinfl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isinfl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns <code>-1</code> if <var>x</var> represents negative infinity,
 <code>1</code> if <var>x</var> represents positive infinity, and <code>0</code> otherwise. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isnan</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isnan</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>isnanf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isnanf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>isnanl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>isnanl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a nonzero value if <var>x</var> is a "not a number"
 value, and zero otherwise.
 
@@ -49593,34 +48494,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>finite</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>finite</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>finitef</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>finitef</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>finitel</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>finitel</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a nonzero value if <var>x</var> is finite or a "not a
 number" value, and zero otherwise. 
 </td></tr>
@@ -49629,27 +48529,27 @@
 <p><strong>Portability Note:</strong> The functions listed in this section are BSD
 extensions.
 
 <p><hr>
-Node:<a name="Floating%20Point%20Errors">Floating Point Errors</a>,
+Node:<a name="Floating Point Errors">Floating Point Errors</a>,
 Next:<a rel=next accesskey=n href="#Rounding">Rounding</a>,
-Previous:<a rel=previous accesskey=p href="#Floating%20Point%20Classes">Floating Point Classes</a>,
+Previous:<a rel=previous accesskey=p href="#Floating Point Classes">Floating Point Classes</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Errors in Floating-Point Calculations</h3>
 
 <ul>
-<li><a accesskey=1 href="#FP%20Exceptions">FP Exceptions</a>:                IEEE 754 math exceptions and how to detect them. 
-<li><a accesskey=2 href="#Infinity%20and%20NaN">Infinity and NaN</a>:             Special values returned by calculations. 
-<li><a accesskey=3 href="#Status%20bit%20operations">Status bit operations</a>:        Checking for exceptions after the fact. 
-<li><a accesskey=4 href="#Math%20Error%20Reporting">Math Error Reporting</a>:         How the math functions report errors. 
+<li><a accesskey=1 href="#FP Exceptions">FP Exceptions</a>:                IEEE 754 math exceptions and how to detect them. 
+<li><a accesskey=2 href="#Infinity and NaN">Infinity and NaN</a>:             Special values returned by calculations. 
+<li><a accesskey=3 href="#Status bit operations">Status bit operations</a>:        Checking for exceptions after the fact. 
+<li><a accesskey=4 href="#Math Error Reporting">Math Error Reporting</a>:         How the math functions report errors. 
 </ul>
 
 <p><hr>
-Node:<a name="FP%20Exceptions">FP Exceptions</a>,
-Next:<a rel=next accesskey=n href="#Infinity%20and%20NaN">Infinity and NaN</a>,
-Up:<a rel=up accesskey=u href="#Floating%20Point%20Errors">Floating Point Errors</a>
+Node:<a name="FP Exceptions">FP Exceptions</a>,
+Next:<a rel=next accesskey=n href="#Infinity and NaN">Infinity and NaN</a>,
+Up:<a rel=up accesskey=u href="#Floating Point Errors">Floating Point Errors</a>
 <br>
 
 <h4>FP Exceptions</h4>
 
@@ -49667,9 +48567,9 @@
 
 <p>Alternatively, you can enable <dfn>traps</dfn> for exceptions.  In that case,
 when an exception is raised, your program will receive the <code>SIGFPE</code>
 signal.  The default action for this signal is to terminate the
-program.  See <a href="#Signal%20Handling">Signal Handling</a>, for how you can change the effect of
+program.  See <a href="#Signal Handling">Signal Handling</a>, for how you can change the effect of
 the signal.
 
 <p>In the System V math library, the user-defined function <code>matherr</code>
 is called when certain exceptions occur inside math library functions. 
@@ -49699,9 +48599,9 @@
 to overflow, infinity, or NaN). 
 <li>Conversion of an unrecognizable input string. 
 <li>Comparison via predicates involving &lt; or &gt;, when one or
 other of the operands is NaN.  You can prevent this exception by using
-the unordered comparison functions instead; see <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>.
+the unordered comparison functions instead; see <a href="#FP Comparison Functions">FP Comparison Functions</a>.
 </ol>
 
 <p>If the exception does not trap, the result of the operation is NaN.
 
@@ -49749,12 +48649,12 @@
 an overflow trap. 
 </dl>
 
 <p><hr>
-Node:<a name="Infinity%20and%20NaN">Infinity and NaN</a>,
-Next:<a rel=next accesskey=n href="#Status%20bit%20operations">Status bit operations</a>,
-Previous:<a rel=previous accesskey=p href="#FP%20Exceptions">FP Exceptions</a>,
-Up:<a rel=up accesskey=u href="#Floating%20Point%20Errors">Floating Point Errors</a>
+Node:<a name="Infinity and NaN">Infinity and NaN</a>,
+Next:<a rel=next accesskey=n href="#Status bit operations">Status bit operations</a>,
+Previous:<a rel=previous accesskey=p href="#FP Exceptions">FP Exceptions</a>,
+Up:<a rel=up accesskey=u href="#Floating Point Errors">Floating Point Errors</a>
 <br>
 
 <h4>Infinity and NaN</h4>
 
@@ -49770,9 +48670,9 @@
 sqrt (-1) = NaN
 </pre>
 
 <p>When a calculation produces any of these values, an exception also
-occurs; see <a href="#FP%20Exceptions">FP Exceptions</a>.
+occurs; see <a href="#FP Exceptions">FP Exceptions</a>.
 
 <p>The basic operations and math functions all accept infinity and NaN and
 produce sensible output.  Infinities propagate through calculations as
 one would expect: for example, 2 + &amp;infin; = &amp;infin;,
@@ -49786,46 +48686,44 @@
 except itself and NaN.  NaN is <dfn>unordered</dfn>: it is not equal to,
 greater than, or less than anything, <em>including itself</em>. <code>x ==
 x</code> is false if the value of <code>x</code> is NaN.  You can use this to test
 whether a value is NaN or not, but the recommended way to test for NaN
-is with the <code>isnan</code> function (see <a href="#Floating%20Point%20Classes">Floating Point Classes</a>).  In
+is with the <code>isnan</code> function (see <a href="#Floating Point Classes">Floating Point Classes</a>).  In
 addition, <code>&lt;</code>, <code>&gt;</code>, <code>&lt;=</code>, and <code>&gt;=</code> will raise an
 exception when applied to NaNs.
 
 <p><code>math.h</code> defines macros that allow you to explicitly set a variable
 to infinity or NaN.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">float <b>INFINITY</b><i>
-</i></td>
+<td align="left"><code>float <b>INFINITY</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An expression representing positive infinity.  It is equal to the value
 produced  by mathematical operations like <code>1.0 / 0.0</code>. 
 <code>-INFINITY</code> represents negative infinity.
 
 <p>You can test whether a floating-point value is infinite by comparing it
 to this macro.  However, this is not recommended; you should use the
-<code>isfinite</code> macro instead.  See <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>isfinite</code> macro instead.  See <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <p>This macro was introduced in the ISO&nbsp;C99 standard. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">float <b>NAN</b><i>
-</i></td>
+<td align="left"><code>float <b>NAN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An expression representing a value which is "not a number".  This
 macro is a GNU extension, available only on machines that support the
 "not a number" value--that is to say, on all machines that support
@@ -49845,12 +48743,12 @@
 calculations, unless you explicitly test the sign bit with
 <code>signbit</code> or <code>copysign</code>.
 
 <p><hr>
-Node:<a name="Status%20bit%20operations">Status bit operations</a>,
-Next:<a rel=next accesskey=n href="#Math%20Error%20Reporting">Math Error Reporting</a>,
-Previous:<a rel=previous accesskey=p href="#Infinity%20and%20NaN">Infinity and NaN</a>,
-Up:<a rel=up accesskey=u href="#Floating%20Point%20Errors">Floating Point Errors</a>
+Node:<a name="Status bit operations">Status bit operations</a>,
+Next:<a rel=next accesskey=n href="#Math Error Reporting">Math Error Reporting</a>,
+Previous:<a rel=previous accesskey=p href="#Infinity and NaN">Infinity and NaN</a>,
+Up:<a rel=up accesskey=u href="#Floating Point Errors">Floating Point Errors</a>
 <br>
 
 <h4>Examining the FPU status word</h4>
 
@@ -49884,16 +48782,15 @@
 <p>These functions allow you to clear exception flags, test for exceptions,
 and save and restore the set of exceptions flagged.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>feclearexcept</b><i> (int <var>excepts</var>)
-</i></td>
+<td align="left"><code>int <b>feclearexcept</b><i> (int <var>excepts</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function clears all of the supported exception flags indicated by
 <var>excepts</var>.
 
@@ -49902,16 +48799,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>feraiseexcept</b><i> (int <var>excepts</var>)
-</i></td>
+<td align="left"><code>int <b>feraiseexcept</b><i> (int <var>excepts</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function raises the supported exceptions indicated by
 <var>excepts</var>.  If more than one exception bit in <var>excepts</var> is set
 the order in which the exceptions are raised is undefined except that
@@ -49925,16 +48821,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fetestexcept</b><i> (int <var>excepts</var>)
-</i></td>
+<td align="left"><code>int <b>fetestexcept</b><i> (int <var>excepts</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Test whether the exception flags indicated by the parameter <var>except</var>
 are currently set.  If any of them are, a nonzero value is returned
 which specifies which exceptions are set.  Otherwise the result is zero. 
@@ -49968,16 +48863,15 @@
 save the entire status word and restore it later.  This is done with the
 following functions:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fegetexceptflag</b><i> (fexcept_t *<var>flagp</var>, int <var>excepts</var>)
-</i></td>
+<td align="left"><code>int <b>fegetexceptflag</b><i> (fexcept_t *<var>flagp</var>, int <var>excepts</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function stores in the variable pointed to by <var>flagp</var> an
 implementation-defined value representing the current setting of the
 exception flags indicated by <var>excepts</var>.
@@ -49987,16 +48881,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fesetexceptflag</b><i> (const fexcept_t *<var>flagp</var>, int
-</i></td>
+<td align="left"><code>int <b>fesetexceptflag</b><i> (const fexcept_t *<var>flagp</var>, int</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <var>excepts</var>)
 This function restores the flags for the exceptions indicated by
 <var>excepts</var> to the values stored in the variable pointed to by
@@ -50011,11 +48904,11 @@
 the bit mask returned by <code>fetestexcept</code>.  The type may not even be
 an integer.  Do not attempt to modify an <code>fexcept_t</code> variable.
 
 <p><hr>
-Node:<a name="Math%20Error%20Reporting">Math Error Reporting</a>,
-Previous:<a rel=previous accesskey=p href="#Status%20bit%20operations">Status bit operations</a>,
-Up:<a rel=up accesskey=u href="#Floating%20Point%20Errors">Floating Point Errors</a>
+Node:<a name="Math Error Reporting">Math Error Reporting</a>,
+Previous:<a rel=previous accesskey=p href="#Status bit operations">Status bit operations</a>,
+Up:<a rel=up accesskey=u href="#Floating Point Errors">Floating Point Errors</a>
 <br>
 
 <h4>Error Reporting by Mathematical Functions</h4>
 
@@ -50049,34 +48942,31 @@
 largest representable number).  <code>math.h</code> defines macros you can use
 to test for overflow on both old and new hardware.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>HUGE_VAL</b><i>
-</i></td>
+<td align="left"><code>double <b>HUGE_VAL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>HUGE_VALF</b><i>
-</i></td>
+<td align="left"><code>float <b>HUGE_VALF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>HUGE_VALL</b><i>
-</i></td>
+<td align="left"><code>long double <b>HUGE_VALL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An expression representing a particular very large number.  On machines
 that use IEEE&nbsp;754 floating point format, <code>HUGE_VAL</code> is infinity. 
 On other machines, it's typically the largest positive number that can
@@ -50089,10 +48979,10 @@
 </table>
 
 <p><hr>
 Node:<a name="Rounding">Rounding</a>,
-Next:<a rel=next accesskey=n href="#Control%20Functions">Control Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Floating%20Point%20Errors">Floating Point Errors</a>,
+Next:<a rel=next accesskey=n href="#Control Functions">Control Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Floating Point Errors">Floating Point Errors</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Rounding Modes</h3>
@@ -50145,9 +49035,9 @@
 <dd>Round toward zero. 
 </dl>
 
 <p>Underflow is an unusual case.  Normally, IEEE&nbsp;754 floating point
-numbers are always normalized (see <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>). 
+numbers are always normalized (see <a href="#Floating Point Concepts">Floating Point Concepts</a>). 
 Numbers smaller than 2^r (where r is the minimum exponent,
 <code>FLT_MIN_RADIX-1</code> for <var>float</var>) cannot be represented as
 normalized numbers.  Rounding all such numbers to zero or 2^r
 would cause some algorithms to fail at 0.  Therefore, they are left in
@@ -50165,16 +49055,15 @@
 <p>At any time one of the above four rounding modes is selected.  You can
 find out which one with this function:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fegetround</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>fegetround</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Returns the currently selected rounding mode, represented by one of the
 values of the defined rounding mode macros. 
 </td></tr>
@@ -50182,16 +49071,15 @@
 
 <p>To change the rounding mode, use this function:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fesetround</b><i> (int <var>round</var>)
-</i></td>
+<td align="left"><code>int <b>fesetround</b><i> (int <var>round</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Changes the currently selected rounding mode to <var>round</var>.  If
 <var>round</var> does not correspond to one of the supported rounding modes
 nothing is changed.  <code>fesetround</code> returns zero if it changed the
@@ -50204,10 +49092,10 @@
 program differently for it to work.  The resulting code may run slower. 
 See your compiler documentation for details.
 
 <p><hr>
-Node:<a name="Control%20Functions">Control Functions</a>,
-Next:<a rel=next accesskey=n href="#Arithmetic%20Functions">Arithmetic Functions</a>,
+Node:<a name="Control Functions">Control Functions</a>,
+Next:<a rel=next accesskey=n href="#Arithmetic Functions">Arithmetic Functions</a>,
 Previous:<a rel=previous accesskey=p href="#Rounding">Rounding</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
@@ -50215,9 +49103,9 @@
 
 <p>IEEE&nbsp;754 floating-point implementations allow the programmer to
 decide whether traps will occur for each of the exceptions, by setting
 bits in the <dfn>control word</dfn>.  In C, traps result in the program
-receiving the <code>SIGFPE</code> signal; see <a href="#Signal%20Handling">Signal Handling</a>.
+receiving the <code>SIGFPE</code> signal; see <a href="#Signal Handling">Signal Handling</a>.
 
 <p><strong>Note:</strong> IEEE&nbsp;754 says that trap handlers are given details of
 the exceptional situation, and can set the result value.  C signals do
 not provide any mechanism to pass this information back and forth. 
@@ -50237,16 +49125,15 @@
 
 <p>To save the state of the FPU, use one of these functions:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fegetenv</b><i> (fenv_t *<var>envp</var>)
-</i></td>
+<td align="left"><code>int <b>fegetenv</b><i> (fenv_t *<var>envp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Store the floating-point environment in the variable pointed to by
 <var>envp</var>.
 
@@ -50255,16 +49142,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>feholdexcept</b><i> (fenv_t *<var>envp</var>)
-</i></td>
+<td align="left"><code>int <b>feholdexcept</b><i> (fenv_t *<var>envp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Store the current floating-point environment in the object pointed to by
 <var>envp</var>.  Then clear all exception flags, and set the FPU to trap no
 exceptions.  Not all FPUs support trapping no exceptions; if
@@ -50295,16 +49181,15 @@
 <p>To set the floating-point environment, you can use either of these
 functions:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fesetenv</b><i> (const fenv_t *<var>envp</var>)
-</i></td>
+<td align="left"><code>int <b>fesetenv</b><i> (const fenv_t *<var>envp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Set the floating-point environment to that described by <var>envp</var>.
 
 <p>The function returns zero in case the operation was successful, a
@@ -50312,16 +49197,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>feupdateenv</b><i> (const fenv_t *<var>envp</var>)
-</i></td>
+<td align="left"><code>int <b>feupdateenv</b><i> (const fenv_t *<var>envp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Like <code>fesetenv</code>, this function sets the floating-point environment
 to that described by <var>envp</var>.  However, if any exceptions were
 flagged in the status word before <code>feupdateenv</code> was called, they
@@ -50339,66 +49223,63 @@
 
 <p><strong>Portability Note:</strong> These functions are all GNU extensions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>feenableexcept</b><i> (int <var>excepts</var>)
-</i></td>
+<td align="left"><code>int <b>feenableexcept</b><i> (int <var>excepts</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This functions enables traps for each of the exceptions as indicated by
 the parameter <var>except</var>.  The individual excepetions are described in
-<a href="#Status%20bit%20operations">Status bit operations</a>.  Only the specified exceptions are
+<a href="#Status bit operations">Status bit operations</a>.  Only the specified exceptions are
 enabled, the status of the other exceptions is not changed.
 
 <p>The function returns the previous enabled exceptions in case the
 operation was successful, <code>-1</code> otherwise. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fedisableexcept</b><i> (int <var>excepts</var>)
-</i></td>
+<td align="left"><code>int <b>fedisableexcept</b><i> (int <var>excepts</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This functions disables traps for each of the exceptions as indicated by
 the parameter <var>except</var>.  The individual excepetions are described in
-<a href="#Status%20bit%20operations">Status bit operations</a>.  Only the specified exceptions are
+<a href="#Status bit operations">Status bit operations</a>.  Only the specified exceptions are
 disabled, the status of the other exceptions is not changed.
 
 <p>The function returns the previous enabled exceptions in case the
 operation was successful, <code>-1</code> otherwise. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fegetexcept</b><i> (int <var>excepts</var>)
-</i></td>
+<td align="left"><code>int <b>fegetexcept</b><i> (int <var>excepts</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function returns a bitmask of all currently enabled exceptions.  It
 returns <code>-1</code> in case of failure. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Arithmetic%20Functions">Arithmetic Functions</a>,
-Next:<a rel=next accesskey=n href="#Complex%20Numbers">Complex Numbers</a>,
-Previous:<a rel=previous accesskey=p href="#Control%20Functions">Control Functions</a>,
+Node:<a name="Arithmetic Functions">Arithmetic Functions</a>,
+Next:<a rel=next accesskey=n href="#Complex Numbers">Complex Numbers</a>,
+Previous:<a rel=previous accesskey=p href="#Control Functions">Control Functions</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Arithmetic Functions</h3>
@@ -50407,21 +49288,21 @@
 floating-point numbers.  These include absolute value, maximum and minimum,
 normalization, bit twiddling, rounding, and a few others.
 
 <ul>
-<li><a accesskey=1 href="#Absolute%20Value">Absolute Value</a>:               Absolute values of integers and floats. 
-<li><a accesskey=2 href="#Normalization%20Functions">Normalization Functions</a>:      Extracting exponents and putting them back. 
-<li><a accesskey=3 href="#Rounding%20Functions">Rounding Functions</a>:           Rounding floats to integers. 
-<li><a accesskey=4 href="#Remainder%20Functions">Remainder Functions</a>:          Remainders on division, precisely defined. 
-<li><a accesskey=5 href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>:             Sign bit adjustment.  Adding epsilon. 
-<li><a accesskey=6 href="#FP%20Comparison%20Functions">FP Comparison Functions</a>:      Comparisons without risk of exceptions. 
-<li><a accesskey=7 href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>:           Max, min, positive difference, multiply-add. 
+<li><a accesskey=1 href="#Absolute Value">Absolute Value</a>:               Absolute values of integers and floats. 
+<li><a accesskey=2 href="#Normalization Functions">Normalization Functions</a>:      Extracting exponents and putting them back. 
+<li><a accesskey=3 href="#Rounding Functions">Rounding Functions</a>:           Rounding floats to integers. 
+<li><a accesskey=4 href="#Remainder Functions">Remainder Functions</a>:          Remainders on division, precisely defined. 
+<li><a accesskey=5 href="#FP Bit Twiddling">FP Bit Twiddling</a>:             Sign bit adjustment.  Adding epsilon. 
+<li><a accesskey=6 href="#FP Comparison Functions">FP Comparison Functions</a>:      Comparisons without risk of exceptions. 
+<li><a accesskey=7 href="#Misc FP Arithmetic">Misc FP Arithmetic</a>:           Max, min, positive difference, multiply-add. 
 </ul>
 
 <p><hr>
-Node:<a name="Absolute%20Value">Absolute Value</a>,
-Next:<a rel=next accesskey=n href="#Normalization%20Functions">Normalization Functions</a>,
-Up:<a rel=up accesskey=u href="#Arithmetic%20Functions">Arithmetic Functions</a>
+Node:<a name="Absolute Value">Absolute Value</a>,
+Next:<a rel=next accesskey=n href="#Normalization Functions">Normalization Functions</a>,
+Up:<a rel=up accesskey=u href="#Arithmetic Functions">Arithmetic Functions</a>
 <br>
 
 <h4>Absolute Value</h4>
 
@@ -50436,43 +49317,42 @@
 <code>fabs</code>, <code>fabsf</code> and <code>fabsl</code> are declared in <code>math.h</code>. 
 <code>cabs</code>, <code>cabsf</code> and <code>cabsl</code> are declared in <code>complex.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>abs</b><i> (int <var>number</var>)
-</i></td>
+<td align="left"><code>int <b>abs</b><i> (int <var>number</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long int <b>labs</b><i> (long int <var>number</var>)
-</i></td>
+<td align="left"><code>long int <b>labs</b><i> (long int <var>number</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>llabs</b><i> (long long int <var>number</var>)
-</i></td>
+<td align="left"><code>long long int <b>llabs</b><i> (long long int <var>number</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">intmax_t <b>imaxabs</b><i> (intmax_t <var>number</var>)
-</i></td>
+<td align="left"><code>intmax_t <b>imaxabs</b><i> (intmax_t <var>number</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the absolute value of <var>number</var>.
 
 <p>Most computers use a two's complement integer representation, in which
@@ -50486,127 +49366,124 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>fabs</b><i> (double <var>number</var>)
-</i></td>
+<td align="left"><code>double <b>fabs</b><i> (double <var>number</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>fabsf</b><i> (float <var>number</var>)
-</i></td>
+<td align="left"><code>float <b>fabsf</b><i> (float <var>number</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>fabsl</b><i> (long double <var>number</var>)
-</i></td>
+<td align="left"><code>long double <b>fabsl</b><i> (long double <var>number</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the absolute value of the floating-point number
 <var>number</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>cabs</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>double <b>cabs</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>cabsf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>float <b>cabsf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>cabsl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>long double <b>cabsl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the absolute  value of the complex number <var>z</var>
-(see <a href="#Complex%20Numbers">Complex Numbers</a>).  The absolute value of a complex number is:
+(see <a href="#Complex Numbers">Complex Numbers</a>).  The absolute value of a complex number is:
 
 <br><pre>sqrt (creal (<var>z</var>) * creal (<var>z</var>) + cimag (<var>z</var>) * cimag (<var>z</var>))
 </pre>
 
 <p>This function should always be used instead of the direct formula
 because it takes special care to avoid losing precision.  It may also
 take advantage of hardware support for this operation. See <code>hypot</code>
-in <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>. 
+in <a href="#Exponents and Logarithms">Exponents and Logarithms</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Normalization%20Functions">Normalization Functions</a>,
-Next:<a rel=next accesskey=n href="#Rounding%20Functions">Rounding Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Absolute%20Value">Absolute Value</a>,
-Up:<a rel=up accesskey=u href="#Arithmetic%20Functions">Arithmetic Functions</a>
+Node:<a name="Normalization Functions">Normalization Functions</a>,
+Next:<a rel=next accesskey=n href="#Rounding Functions">Rounding Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Absolute Value">Absolute Value</a>,
+Up:<a rel=up accesskey=u href="#Arithmetic Functions">Arithmetic Functions</a>
 <br>
 
 <h4>Normalization Functions</h4>
 
 <p>The functions described in this section are primarily provided as a way
 to efficiently perform certain low-level manipulations on floating point
 numbers that are represented internally using a binary radix;
-see <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>.  These functions are required to
+see <a href="#Floating Point Concepts">Floating Point Concepts</a>.  These functions are required to
 have equivalent behavior even if the representation does not use a radix
 of 2, but of course they are unlikely to be particularly efficient in
 those cases.
 
 <p>All these functions are declared in <code>math.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>frexp</b><i> (double <var>value</var>, int *<var>exponent</var>)
-</i></td>
+<td align="left"><code>double <b>frexp</b><i> (double <var>value</var>, int *<var>exponent</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>frexpf</b><i> (float <var>value</var>, int *<var>exponent</var>)
-</i></td>
+<td align="left"><code>float <b>frexpf</b><i> (float <var>value</var>, int *<var>exponent</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>frexpl</b><i> (long double <var>value</var>, int *<var>exponent</var>)
-</i></td>
+<td align="left"><code>long double <b>frexpl</b><i> (long double <var>value</var>, int *<var>exponent</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are used to split the number <var>value</var>
 into a normalized fraction and an exponent.
 
@@ -50624,34 +49501,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>ldexp</b><i> (double <var>value</var>, int <var>exponent</var>)
-</i></td>
+<td align="left"><code>double <b>ldexp</b><i> (double <var>value</var>, int <var>exponent</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>ldexpf</b><i> (float <var>value</var>, int <var>exponent</var>)
-</i></td>
+<td align="left"><code>float <b>ldexpf</b><i> (float <var>value</var>, int <var>exponent</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>ldexpl</b><i> (long double <var>value</var>, int <var>exponent</var>)
-</i></td>
+<td align="left"><code>long double <b>ldexpl</b><i> (long double <var>value</var>, int <var>exponent</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the result of multiplying the floating-point
 number <var>value</var> by 2 raised to the power <var>exponent</var>.  (It can
 be used to reassemble floating-point numbers that were taken apart
@@ -50665,132 +49541,128 @@
 equivalent to those of <code>ldexp</code> and <code>frexp</code>.  See also the
 ISO&nbsp;C function <code>logb</code> which originally also appeared in BSD.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>scalb</b><i> (double <var>value</var>, int <var>exponent</var>)
-</i></td>
+<td align="left"><code>double <b>scalb</b><i> (double <var>value</var>, int <var>exponent</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>scalbf</b><i> (float <var>value</var>, int <var>exponent</var>)
-</i></td>
+<td align="left"><code>float <b>scalbf</b><i> (float <var>value</var>, int <var>exponent</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>scalbl</b><i> (long double <var>value</var>, int <var>exponent</var>)
-</i></td>
+<td align="left"><code>long double <b>scalbl</b><i> (long double <var>value</var>, int <var>exponent</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>scalb</code> function is the BSD name for <code>ldexp</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>scalbn</b><i> (double <var>x</var>, int n)
-</i></td>
+<td align="left"><code>long long int <b>scalbn</b><i> (double <var>x</var>, int n)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>scalbnf</b><i> (float <var>x</var>, int n)
-</i></td>
+<td align="left"><code>long long int <b>scalbnf</b><i> (float <var>x</var>, int n)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>scalbnl</b><i> (long double <var>x</var>, int n)
-</i></td>
+<td align="left"><code>long long int <b>scalbnl</b><i> (long double <var>x</var>, int n)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>scalbn</code> is identical to <code>scalb</code>, except that the exponent
 <var>n</var> is an <code>int</code> instead of a floating-point number. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>scalbln</b><i> (double <var>x</var>, long int n)
-</i></td>
+<td align="left"><code>long long int <b>scalbln</b><i> (double <var>x</var>, long int n)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>scalblnf</b><i> (float <var>x</var>, long int n)
-</i></td>
+<td align="left"><code>long long int <b>scalblnf</b><i> (float <var>x</var>, long int n)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>scalblnl</b><i> (long double <var>x</var>, long int n)
-</i></td>
+<td align="left"><code>long long int <b>scalblnl</b><i> (long double <var>x</var>, long int n)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>scalbln</code> is identical to <code>scalb</code>, except that the exponent
 <var>n</var> is a <code>long int</code> instead of a floating-point number. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>significand</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>significand</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>significandf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>significandf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>significandl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>significandl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>significand</code> returns the mantissa of <var>x</var> scaled to the range
 [1, 2). 
 It is equivalent to <code>scalb&nbsp;(<var>x</var>,&nbsp;(double)&nbsp;-ilogb&nbsp;(<var>x</var>))</code>.
@@ -50800,12 +49672,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Rounding%20Functions">Rounding Functions</a>,
-Next:<a rel=next accesskey=n href="#Remainder%20Functions">Remainder Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Normalization%20Functions">Normalization Functions</a>,
-Up:<a rel=up accesskey=u href="#Arithmetic%20Functions">Arithmetic Functions</a>
+Node:<a name="Rounding Functions">Rounding Functions</a>,
+Next:<a rel=next accesskey=n href="#Remainder Functions">Remainder Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Normalization Functions">Normalization Functions</a>,
+Up:<a rel=up accesskey=u href="#Arithmetic Functions">Arithmetic Functions</a>
 <br>
 
 <h4>Rounding Functions</h4>
 
@@ -50821,139 +49693,135 @@
 numbers, this is impossible.  The functions listed here return the
 result as a <code>double</code> instead to get around this problem.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>ceil</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>ceil</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>ceilf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>ceilf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>ceill</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>ceill</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions round <var>x</var> upwards to the nearest integer,
 returning that value as a <code>double</code>.  Thus, <code>ceil (1.5)</code>
 is <code>2.0</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>floor</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>floor</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>floorf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>floorf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>floorl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>floorl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions round <var>x</var> downwards to the nearest
 integer, returning that value as a <code>double</code>.  Thus, <code>floor
 (1.5)</code> is <code>1.0</code> and <code>floor (-1.5)</code> is <code>-2.0</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>trunc</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>trunc</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>truncf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>truncf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>truncl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>truncl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>trunc</code> functions round <var>x</var> towards zero to the nearest
 integer (returned in floating-point format).  Thus, <code>trunc (1.5)</code>
 is <code>1.0</code> and <code>trunc (-1.5)</code> is <code>-1.0</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>rint</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>rint</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>rintf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>rintf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>rintl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>rintl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions round <var>x</var> to an integer value according to the
-current rounding mode.  See <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>, for
+current rounding mode.  See <a href="#Floating Point Parameters">Floating Point Parameters</a>, for
 information about the various rounding modes.  The default
 rounding mode is to round to the nearest integer; some machines
 support other modes, but round-to-nearest is always used unless
 you explicitly select another.
@@ -50963,232 +49831,225 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>nearbyint</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>nearbyint</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>nearbyintf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>nearbyintf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>nearbyintl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>nearbyintl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the same value as the <code>rint</code> functions, but
 do not raise the inexact exception if <var>x</var> is not an integer. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>round</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>double <b>round</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>roundf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>float <b>roundf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>roundl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long double <b>roundl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are similar to <code>rint</code>, but they round halfway
 cases away from zero instead of to the nearest even integer. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>lrint</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>long int <b>lrint</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long int <b>lrintf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>long int <b>lrintf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long int <b>lrintl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long int <b>lrintl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are just like <code>rint</code>, but they return a
 <code>long int</code> instead of a floating-point number. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>llrint</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>llrint</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>llrintf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>llrintf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>llrintl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>llrintl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are just like <code>rint</code>, but they return a
 <code>long long int</code> instead of a floating-point number. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>lround</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>long int <b>lround</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long int <b>lroundf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>long int <b>lroundf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long int <b>lroundl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long int <b>lroundl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are just like <code>round</code>, but they return a
 <code>long int</code> instead of a floating-point number. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>llround</b><i> (double <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>llround</b><i> (double <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>llroundf</b><i> (float <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>llroundf</b><i> (float <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long long int <b>llroundl</b><i> (long double <var>x</var>)
-</i></td>
+<td align="left"><code>long long int <b>llroundl</b><i> (long double <var>x</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are just like <code>round</code>, but they return a
 <code>long long int</code> instead of a floating-point number. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>modf</b><i> (double <var>value</var>, double *<var>integer-part</var>)
-</i></td>
+<td align="left"><code>double <b>modf</b><i> (double <var>value</var>, double *<var>integer-part</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>modff</b><i> (float <var>value</var>, float *<var>integer-part</var>)
-</i></td>
+<td align="left"><code>float <b>modff</b><i> (float <var>value</var>, float *<var>integer-part</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>modfl</b><i> (long double <var>value</var>, long double *<var>integer-part</var>)
-</i></td>
+<td align="left"><code>long double <b>modfl</b><i> (long double <var>value</var>, long double *<var>integer-part</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions break the argument <var>value</var> into an integer part and a
 fractional part (between <code>-1</code> and <code>1</code>, exclusive).  Their sum
 equals <var>value</var>.  Each of the parts has the same sign as <var>value</var>,
@@ -51200,12 +50061,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Remainder%20Functions">Remainder Functions</a>,
-Next:<a rel=next accesskey=n href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>,
-Previous:<a rel=previous accesskey=p href="#Rounding%20Functions">Rounding Functions</a>,
-Up:<a rel=up accesskey=u href="#Arithmetic%20Functions">Arithmetic Functions</a>
+Node:<a name="Remainder Functions">Remainder Functions</a>,
+Next:<a rel=next accesskey=n href="#FP Bit Twiddling">FP Bit Twiddling</a>,
+Previous:<a rel=previous accesskey=p href="#Rounding Functions">Rounding Functions</a>,
+Up:<a rel=up accesskey=u href="#Arithmetic Functions">Arithmetic Functions</a>
 <br>
 
 <h4>Remainder Functions</h4>
 
@@ -51213,34 +50074,33 @@
 floating-point numbers.  Each is a little different; pick the one that
 suits your problem.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>fmod</b><i> (double <var>numerator</var>, double <var>denominator</var>)
-</i></td>
+<td align="left"><code>double <b>fmod</b><i> (double <var>numerator</var>, double <var>denominator</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>fmodf</b><i> (float <var>numerator</var>, float <var>denominator</var>)
-</i></td>
+<td align="left"><code>float <b>fmodf</b><i> (float <var>numerator</var>, float <var>denominator</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>fmodl</b><i> (long double <var>numerator</var>, long double <var>denominator</var>)
-</i></td>
+<td align="left"><code>long double <b>fmodl</b><i> (long double <var>numerator</var>, long double <var>denominator</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions compute the remainder from the division of
 <var>numerator</var> by <var>denominator</var>.  Specifically, the return value is
 <code><var>numerator</var> - <var>n</var>&nbsp;*&nbsp;<var>denominator</var></code>, where <var>n</var>
@@ -51255,34 +50115,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>drem</b><i> (double <var>numerator</var>, double <var>denominator</var>)
-</i></td>
+<td align="left"><code>double <b>drem</b><i> (double <var>numerator</var>, double <var>denominator</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>dremf</b><i> (float <var>numerator</var>, float <var>denominator</var>)
-</i></td>
+<td align="left"><code>float <b>dremf</b><i> (float <var>numerator</var>, float <var>denominator</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>dreml</b><i> (long double <var>numerator</var>, long double <var>denominator</var>)
-</i></td>
+<td align="left"><code>long double <b>dreml</b><i> (long double <var>numerator</var>, long double <var>denominator</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are like <code>fmod</code> except that they rounds the
 internal quotient <var>n</var> to the nearest integer instead of towards zero
 to an integer.  For example, <code>drem (6.5, 2.3)</code> returns <code>-0.4</code>,
@@ -51298,44 +50157,43 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>remainder</b><i> (double <var>numerator</var>, double <var>denominator</var>)
-</i></td>
+<td align="left"><code>double <b>remainder</b><i> (double <var>numerator</var>, double <var>denominator</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>remainderf</b><i> (float <var>numerator</var>, float <var>denominator</var>)
-</i></td>
+<td align="left"><code>float <b>remainderf</b><i> (float <var>numerator</var>, float <var>denominator</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>remainderl</b><i> (long double <var>numerator</var>, long double <var>denominator</var>)
-</i></td>
+<td align="left"><code>long double <b>remainderl</b><i> (long double <var>numerator</var>, long double <var>denominator</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is another name for <code>drem</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="FP%20Bit%20Twiddling">FP Bit Twiddling</a>,
-Next:<a rel=next accesskey=n href="#FP%20Comparison%20Functions">FP Comparison Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Remainder%20Functions">Remainder Functions</a>,
-Up:<a rel=up accesskey=u href="#Arithmetic%20Functions">Arithmetic Functions</a>
+Node:<a name="FP Bit Twiddling">FP Bit Twiddling</a>,
+Next:<a rel=next accesskey=n href="#FP Comparison Functions">FP Comparison Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Remainder Functions">Remainder Functions</a>,
+Up:<a rel=up accesskey=u href="#Arithmetic Functions">Arithmetic Functions</a>
 <br>
 
 <h4>Setting and modifying single bits of FP values</h4>
 
@@ -51344,34 +50202,33 @@
 functions to do these operations, which mostly involve changing single
 bits.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>copysign</b><i> (double <var>x</var>, double <var>y</var>)
-</i></td>
+<td align="left"><code>double <b>copysign</b><i> (double <var>x</var>, double <var>y</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>copysignf</b><i> (float <var>x</var>, float <var>y</var>)
-</i></td>
+<td align="left"><code>float <b>copysignf</b><i> (float <var>x</var>, float <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>copysignl</b><i> (long double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>long double <b>copysignl</b><i> (long double <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return <var>x</var> but with the sign of <var>y</var>.  They work
 even if <var>x</var> or <var>y</var> are NaN or zero.  Both of these can carry a
 sign (although not all implementations support it) and this is one of
@@ -51384,16 +50241,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>signbit</b><i> (<em>float-type</em> <var>x</var>)
-</i></td>
+<td align="left"><code>int <b>signbit</b><i> (<em>float-type</em> <var>x</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>signbit</code> is a generic macro which can work on all floating-point
 types.  It returns a nonzero value if the value of <var>x</var> has its sign
 bit set.
@@ -51404,34 +50260,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>nextafter</b><i> (double <var>x</var>, double <var>y</var>)
-</i></td>
+<td align="left"><code>double <b>nextafter</b><i> (double <var>x</var>, double <var>y</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>nextafterf</b><i> (float <var>x</var>, float <var>y</var>)
-</i></td>
+<td align="left"><code>float <b>nextafterf</b><i> (float <var>x</var>, float <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>nextafterl</b><i> (long double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>long double <b>nextafterl</b><i> (long double <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>nextafter</code> function returns the next representable neighbor of
 <var>x</var> in the direction towards <var>y</var>.  The size of the step between
 <var>x</var> and the result depends on the type of the result.  If
@@ -51447,68 +50302,66 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>nexttoward</b><i> (double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>double <b>nexttoward</b><i> (double <var>x</var>, long double <var>y</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>nexttowardf</b><i> (float <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>float <b>nexttowardf</b><i> (float <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>nexttowardl</b><i> (long double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>long double <b>nexttowardl</b><i> (long double <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are identical to the corresponding versions of
 <code>nextafter</code> except that their second argument is a <code>long
 double</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>nan</b><i> (const char *<var>tagp</var>)
-</i></td>
+<td align="left"><code>double <b>nan</b><i> (const char *<var>tagp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>nanf</b><i> (const char *<var>tagp</var>)
-</i></td>
+<td align="left"><code>float <b>nanf</b><i> (const char *<var>tagp</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>nanl</b><i> (const char *<var>tagp</var>)
-</i></td>
+<td align="left"><code>long double <b>nanl</b><i> (const char *<var>tagp</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>nan</code> function returns a representation of NaN, provided that
 NaN is supported by the target platform. 
 <code>nan ("<var>n-char-sequence</var>")</code> is equivalent to
@@ -51519,12 +50372,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="FP%20Comparison%20Functions">FP Comparison Functions</a>,
-Next:<a rel=next accesskey=n href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>,
-Previous:<a rel=previous accesskey=p href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>,
-Up:<a rel=up accesskey=u href="#Arithmetic%20Functions">Arithmetic Functions</a>
+Node:<a name="FP Comparison Functions">FP Comparison Functions</a>,
+Next:<a rel=next accesskey=n href="#Misc FP Arithmetic">Misc FP Arithmetic</a>,
+Previous:<a rel=previous accesskey=p href="#FP Bit Twiddling">FP Bit Twiddling</a>,
+Up:<a rel=up accesskey=u href="#Arithmetic Functions">Arithmetic Functions</a>
 <br>
 
 <h4>Floating-Point Comparison Functions</h4>
 
@@ -51543,80 +50396,75 @@
 floating-point type.  The macros are guaranteed to evaluate their
 arguments only once.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isgreater</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)
-</i></td>
+<td align="left"><code>int <b>isgreater</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro determines whether the argument <var>x</var> is greater than
 <var>y</var>.  It is equivalent to <code>(<var>x</var>) &gt; (<var>y</var>)</code>, but no
 exception is raised if <var>x</var> or <var>y</var> are NaN. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isgreaterequal</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)
-</i></td>
+<td align="left"><code>int <b>isgreaterequal</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro determines whether the argument <var>x</var> is greater than or
 equal to <var>y</var>.  It is equivalent to <code>(<var>x</var>) &gt;= (<var>y</var>)</code>, but no
 exception is raised if <var>x</var> or <var>y</var> are NaN. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isless</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)
-</i></td>
+<td align="left"><code>int <b>isless</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro determines whether the argument <var>x</var> is less than <var>y</var>. 
 It is equivalent to <code>(<var>x</var>) &lt; (<var>y</var>)</code>, but no exception is
 raised if <var>x</var> or <var>y</var> are NaN. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>islessequal</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)
-</i></td>
+<td align="left"><code>int <b>islessequal</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro determines whether the argument <var>x</var> is less than or equal
 to <var>y</var>.  It is equivalent to <code>(<var>x</var>) &lt;= (<var>y</var>)</code>, but no
 exception is raised if <var>x</var> or <var>y</var> are NaN. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>islessgreater</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)
-</i></td>
+<td align="left"><code>int <b>islessgreater</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro determines whether the argument <var>x</var> is less or greater
 than <var>y</var>.  It is equivalent to <code>(<var>x</var>) &lt; (<var>y</var>) ||
 (<var>x</var>) &gt; (<var>y</var>)</code> (although it only evaluates <var>x</var> and <var>y</var>
@@ -51627,16 +50475,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>isunordered</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)
-</i></td>
+<td align="left"><code>int <b>isunordered</b><i> (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro determines whether its arguments are unordered.  In other
 words, it is true if <var>x</var> or <var>y</var> are NaN, and false otherwise. 
 </td></tr>
@@ -51650,11 +50497,11 @@
 They are unnecessary, because the <code>==</code> and <code>!=</code> operators do
 <em>not</em> throw an exception if one or both of the operands are NaN.
 
 <p><hr>
-Node:<a name="Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>,
-Previous:<a rel=previous accesskey=p href="#FP%20Comparison%20Functions">FP Comparison Functions</a>,
-Up:<a rel=up accesskey=u href="#Arithmetic%20Functions">Arithmetic Functions</a>
+Node:<a name="Misc FP Arithmetic">Misc FP Arithmetic</a>,
+Previous:<a rel=previous accesskey=p href="#FP Comparison Functions">FP Comparison Functions</a>,
+Up:<a rel=up accesskey=u href="#Arithmetic Functions">Arithmetic Functions</a>
 <br>
 
 <h4>Miscellaneous FP arithmetic functions</h4>
 
@@ -51663,34 +50510,33 @@
 processors these functions can use special machine instructions to
 perform these operations faster than the equivalent C code.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>fmin</b><i> (double <var>x</var>, double <var>y</var>)
-</i></td>
+<td align="left"><code>double <b>fmin</b><i> (double <var>x</var>, double <var>y</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>fminf</b><i> (float <var>x</var>, float <var>y</var>)
-</i></td>
+<td align="left"><code>float <b>fminf</b><i> (float <var>x</var>, float <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>fminl</b><i> (long double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>long double <b>fminl</b><i> (long double <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fmin</code> function returns the lesser of the two values <var>x</var>
 and <var>y</var>.  It is similar to the expression
 <br><pre>((x) &lt; (y) ? (x) : (y))
@@ -51702,34 +50548,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>fmax</b><i> (double <var>x</var>, double <var>y</var>)
-</i></td>
+<td align="left"><code>double <b>fmax</b><i> (double <var>x</var>, double <var>y</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>fmaxf</b><i> (float <var>x</var>, float <var>y</var>)
-</i></td>
+<td align="left"><code>float <b>fmaxf</b><i> (float <var>x</var>, float <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>fmaxl</b><i> (long double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>long double <b>fmaxl</b><i> (long double <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fmax</code> function returns the greater of the two values <var>x</var>
 and <var>y</var>.
 
@@ -51738,34 +50583,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>fdim</b><i> (double <var>x</var>, double <var>y</var>)
-</i></td>
+<td align="left"><code>double <b>fdim</b><i> (double <var>x</var>, double <var>y</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>fdimf</b><i> (float <var>x</var>, float <var>y</var>)
-</i></td>
+<td align="left"><code>float <b>fdimf</b><i> (float <var>x</var>, float <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>fdiml</b><i> (long double <var>x</var>, long double <var>y</var>)
-</i></td>
+<td align="left"><code>long double <b>fdiml</b><i> (long double <var>x</var>, long double <var>y</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fdim</code> function returns the positive difference between
 <var>x</var> and <var>y</var>.  The positive difference is <var>x</var> -
 <var>y</var> if <var>x</var> is greater than <var>y</var>, and 0 otherwise.
@@ -51774,34 +50618,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>fma</b><i> (double <var>x</var>, double <var>y</var>, double <var>z</var>)
-</i></td>
+<td align="left"><code>double <b>fma</b><i> (double <var>x</var>, double <var>y</var>, double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>fmaf</b><i> (float <var>x</var>, float <var>y</var>, float <var>z</var>)
-</i></td>
+<td align="left"><code>float <b>fmaf</b><i> (float <var>x</var>, float <var>y</var>, float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>fmal</b><i> (long double <var>x</var>, long double <var>y</var>, long double <var>z</var>)
-</i></td>
+<td align="left"><code>long double <b>fmal</b><i> (long double <var>x</var>, long double <var>y</var>, long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fma</code> function performs floating-point multiply-add.  This is
 the operation (<var>x</var> &amp;middot; <var>y</var>) + <var>z</var>, but the
 intermediate result is not rounded to the destination type.  This can
@@ -51823,11 +50666,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Complex%20Numbers">Complex Numbers</a>,
-Next:<a rel=next accesskey=n href="#Operations%20on%20Complex">Operations on Complex</a>,
-Previous:<a rel=previous accesskey=p href="#Arithmetic%20Functions">Arithmetic Functions</a>,
+Node:<a name="Complex Numbers">Complex Numbers</a>,
+Next:<a rel=next accesskey=n href="#Operations on Complex">Operations on Complex</a>,
+Previous:<a rel=previous accesskey=p href="#Arithmetic Functions">Arithmetic Functions</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Complex Numbers</h3>
@@ -51843,16 +50686,15 @@
 floating point constant.  Instead, <code>complex.h</code> defines two macros
 that can be used to create complex numbers.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">const float complex <b>_Complex_I</b><i>
-</i></td>
+<td align="left"><code>const float complex <b>_Complex_I</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is a representation of the complex number "0+1i". 
 Multiplying a real floating-point value by <code>_Complex_I</code> gives a
 complex number whose value is purely imaginary.  You can use this to
@@ -51869,16 +50711,15 @@
 <p><code>_Complex_I</code> is a bit of a mouthful.  <code>complex.h</code> also defines
 a shorter name for the same constant.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">const float complex <b>I</b><i>
-</i></td>
+<td align="left"><code>const float complex <b>I</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro has exactly the same value as <code>_Complex_I</code>.  Most of the
 time it is preferable.  However, it causes problems if you want to use
 the identifier <code>I</code> for something else.  You can safely write
@@ -51894,11 +50735,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Operations%20on%20Complex">Operations on Complex</a>,
-Next:<a rel=next accesskey=n href="#Parsing%20of%20Numbers">Parsing of Numbers</a>,
-Previous:<a rel=previous accesskey=p href="#Complex%20Numbers">Complex Numbers</a>,
+Node:<a name="Operations on Complex">Operations on Complex</a>,
+Next:<a rel=next accesskey=n href="#Parsing of Numbers">Parsing of Numbers</a>,
+Previous:<a rel=previous accesskey=p href="#Complex Numbers">Complex Numbers</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Projections, Conjugates, and Decomposing of Complex Numbers</h3>
@@ -51908,132 +50749,128 @@
 for all these functions are in <code>complex.h</code>.  All functions are
 available in three variants, one for each of the three complex types.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>creal</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>double <b>creal</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>crealf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>float <b>crealf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>creall</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>long double <b>creall</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the real part of the complex number <var>z</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>cimag</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>double <b>cimag</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>cimagf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>float <b>cimagf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>cimagl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>long double <b>cimagl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the imaginary part of the complex number <var>z</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>conj</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>conj</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>conjf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>conjf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>conjl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>conjl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the conjugate value of the complex number
 <var>z</var>.  The conjugate of a complex number has the same real part and a
 negated imaginary part.  In other words, <code>conj(a + bi) = a + -bi</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>carg</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>double <b>carg</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>cargf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>float <b>cargf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>cargl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>long double <b>cargl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the argument of the complex number <var>z</var>. 
 The argument of a complex number is the angle in the complex plane
 between the positive real axis and a line passing through zero and the
@@ -52044,34 +50881,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">complex double <b>cproj</b><i> (complex double <var>z</var>)
-</i></td>
+<td align="left"><code>complex double <b>cproj</b><i> (complex double <var>z</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex float <b>cprojf</b><i> (complex float <var>z</var>)
-</i></td>
+<td align="left"><code>complex float <b>cprojf</b><i> (complex float <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">complex long double <b>cprojl</b><i> (complex long double <var>z</var>)
-</i></td>
+<td align="left"><code>complex long double <b>cprojl</b><i> (complex long double <var>z</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions return the projection of the complex value <var>z</var> onto
 the Riemann sphere.  Values with a infinite imaginary part are projected
 to positive infinity on the real axis, even if the real part is NaN.  If
@@ -52082,33 +50918,33 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Parsing%20of%20Numbers">Parsing of Numbers</a>,
-Next:<a rel=next accesskey=n href="#System%20V%20Number%20Conversion">System V Number Conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Operations%20on%20Complex">Operations on Complex</a>,
+Node:<a name="Parsing of Numbers">Parsing of Numbers</a>,
+Next:<a rel=next accesskey=n href="#System V Number Conversion">System V Number Conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Operations on Complex">Operations on Complex</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Parsing of Numbers</h3>
 
 <p>This section describes functions for "reading" integer and
 floating-point numbers from a string.  It may be more convenient in some
 cases to use <code>sscanf</code> or one of the related functions; see
-<a href="#Formatted%20Input">Formatted Input</a>.  But often you can make a program more robust by
+<a href="#Formatted Input">Formatted Input</a>.  But often you can make a program more robust by
 finding the tokens in the string by hand, then converting the numbers
 one by one.
 
 <ul>
-<li><a accesskey=1 href="#Parsing%20of%20Integers">Parsing of Integers</a>:          Functions for conversion of integer values. 
-<li><a accesskey=2 href="#Parsing%20of%20Floats">Parsing of Floats</a>:            Functions for conversion of floating-point
+<li><a accesskey=1 href="#Parsing of Integers">Parsing of Integers</a>:          Functions for conversion of integer values. 
+<li><a accesskey=2 href="#Parsing of Floats">Parsing of Floats</a>:            Functions for conversion of floating-point
 				 values. 
 </ul>
 
 <p><hr>
-Node:<a name="Parsing%20of%20Integers">Parsing of Integers</a>,
-Next:<a rel=next accesskey=n href="#Parsing%20of%20Floats">Parsing of Floats</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20of%20Numbers">Parsing of Numbers</a>
+Node:<a name="Parsing of Integers">Parsing of Integers</a>,
+Next:<a rel=next accesskey=n href="#Parsing of Floats">Parsing of Floats</a>,
+Up:<a rel=up accesskey=u href="#Parsing of Numbers">Parsing of Numbers</a>
 <br>
 
 <h4>Parsing of Integers</h4>
 
@@ -52119,16 +50955,15 @@
 standard uses it (for the functions defined there) so we have to do it
 as well.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>strtol</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>long int <b>strtol</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strtol</code> ("string-to-long") function converts the initial
 part of <var>string</var> to a signed integer, which is returned as a value
 of type <code>long int</code>.
@@ -52137,9 +50972,9 @@
 
 <ul>
 <li>A (possibly empty) sequence of whitespace characters.  Which characters
 are whitespace is determined by the <code>isspace</code> function
-(see <a href="#Classification%20of%20Characters">Classification of Characters</a>).  These are discarded.
+(see <a href="#Classification of Characters">Classification of Characters</a>).  These are discarded.
 
 <li>An optional plus or minus sign (<code>+</code> or <code>-</code>).
 
 <li>A nonempty sequence of digits in the radix specified by <var>base</var>.
@@ -52169,9 +51004,9 @@
 may recognize additional implementation-dependent syntax.
 
 <p>If the string has valid syntax for an integer but the value is not
 representable because of overflow, <code>strtol</code> returns either
-<code>LONG_MAX</code> or <code>LONG_MIN</code> (see <a href="#Range%20of%20Type">Range of Type</a>), as
+<code>LONG_MAX</code> or <code>LONG_MIN</code> (see <a href="#Range of Type">Range of Type</a>), as
 appropriate for the sign of the value.  It also sets <code>errno</code>
 to <code>ERANGE</code> to indicate there was overflow.
 
 <p>You should not check for errors by examining the return value of
@@ -52186,16 +51021,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>wcstol</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>long int <b>wcstol</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstol</code> function is equivalent to the <code>strtol</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52203,21 +51037,20 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned long int <b>strtoul</b><i> (const char *retrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>unsigned long int <b>strtoul</b><i> (const char *retrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strtoul</code> ("string-to-unsigned-long") function is like
 <code>strtol</code> except it converts to an <code>unsigned long int</code> value. 
 The syntax is the same as described above for <code>strtol</code>.  The value
-returned on overflow is <code>ULONG_MAX</code> (see <a href="#Range%20of%20Type">Range of Type</a>).
+returned on overflow is <code>ULONG_MAX</code> (see <a href="#Range of Type">Range of Type</a>).
 
 <p>If <var>string</var> depicts a negative number, <code>strtoul</code> acts the same
 as <var>strtol</var> but casts the result to an unsigned integer.  That means
 for example that <code>strtoul</code> on <code>"-1"</code> returns <code>ULONG_MAX</code>
@@ -52229,16 +51062,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned long int <b>wcstoul</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>unsigned long int <b>wcstoul</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstoul</code> function is equivalent to the <code>strtoul</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52246,40 +51078,38 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>strtoll</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>long long int <b>strtoll</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strtoll</code> function is like <code>strtol</code> except that it returns
 a <code>long long int</code> value, and accepts numbers with a correspondingly
 larger range.
 
 <p>If the string has valid syntax for an integer but the value is not
 representable because of overflow, <code>strtoll</code> returns either
-<code>LONG_LONG_MAX</code> or <code>LONG_LONG_MIN</code> (see <a href="#Range%20of%20Type">Range of Type</a>), as
+<code>LONG_LONG_MAX</code> or <code>LONG_LONG_MIN</code> (see <a href="#Range of Type">Range of Type</a>), as
 appropriate for the sign of the value.  It also sets <code>errno</code> to
 <code>ERANGE</code> to indicate there was overflow.
 
 <p>The <code>strtoll</code> function was introduced in ISO&nbsp;C99. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>wcstoll</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>long long int <b>wcstoll</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstoll</code> function is equivalent to the <code>strtoll</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52287,30 +51117,28 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>strtoq</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>long long int <b>strtoq</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>strtoq</code> ("string-to-quad-word") is the BSD name for <code>strtoll</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>wcstoq</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>long long int <b>wcstoq</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstoq</code> function is equivalent to the <code>strtoq</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52318,16 +51146,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned long long int <b>strtoull</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>unsigned long long int <b>strtoull</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strtoull</code> function is related to <code>strtoll</code> the same way
 <code>strtoul</code> is related to <code>strtol</code>.
 
@@ -52335,16 +51162,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned long long int <b>wcstoull</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>unsigned long long int <b>wcstoull</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstoull</code> function is equivalent to the <code>strtoull</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52352,30 +51178,28 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned long long int <b>strtouq</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>unsigned long long int <b>strtouq</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>strtouq</code> is the BSD name for <code>strtoull</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned long long int <b>wcstouq</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>unsigned long long int <b>wcstouq</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstouq</code> function is equivalent to the <code>strtouq</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52383,16 +51207,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">intmax_t <b>strtoimax</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>intmax_t <b>strtoimax</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strtoimax</code> function is like <code>strtol</code> except that it returns
 a <code>intmax_t</code> value, and accepts numbers of a corresponding range.
 
@@ -52407,16 +51230,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">intmax_t <b>wcstoimax</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>intmax_t <b>wcstoimax</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstoimax</code> function is equivalent to the <code>strtoimax</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52424,16 +51246,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uintmax_t <b>strtoumax</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>uintmax_t <b>strtoumax</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strtoumax</code> function is related to <code>strtoimax</code>
 the same way that <code>strtoul</code> is related to <code>strtol</code>.
 
@@ -52442,16 +51263,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uintmax_t <b>wcstoumax</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)
-</i></td>
+<td align="left"><code>uintmax_t <b>wcstoumax</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstoumax</code> function is equivalent to the <code>strtoumax</code> function
 in nearly all aspects but handles wide character strings.
 
@@ -52459,16 +51279,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>atol</b><i> (const char *<var>string</var>)
-</i></td>
+<td align="left"><code>long int <b>atol</b><i> (const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>strtol</code> function with a <var>base</var>
 argument of <code>10</code>, except that it need not detect overflow errors. 
 The <code>atol</code> function is provided mostly for compatibility with
@@ -52476,32 +51295,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>atoi</b><i> (const char *<var>string</var>)
-</i></td>
+<td align="left"><code>int <b>atoi</b><i> (const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>atol</code>, except that it returns an <code>int</code>. 
 The <code>atoi</code> function is also considered obsolete; use <code>strtol</code>
 instead. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long long int <b>atoll</b><i> (const char *<var>string</var>)
-</i></td>
+<td align="left"><code>long long int <b>atoll</b><i> (const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>atol</code>, except it returns a <code>long
 long int</code>.
 
@@ -52552,11 +51369,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Parsing%20of%20Floats">Parsing of Floats</a>,
-Previous:<a rel=previous accesskey=p href="#Parsing%20of%20Integers">Parsing of Integers</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20of%20Numbers">Parsing of Numbers</a>
+Node:<a name="Parsing of Floats">Parsing of Floats</a>,
+Previous:<a rel=previous accesskey=p href="#Parsing of Integers">Parsing of Integers</a>,
+Up:<a rel=up accesskey=u href="#Parsing of Numbers">Parsing of Numbers</a>
 <br>
 
 <h4>Parsing of Floats</h4>
 
@@ -52567,16 +51384,15 @@
 standard uses it (for the functions defined there) so we have to do it
 as well.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>strtod</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>)
-</i></td>
+<td align="left"><code>double <b>strtod</b><i> (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strtod</code> ("string-to-double") function converts the initial
 part of <var>string</var> to a floating-point number, which is returned as a
 value of type <code>double</code>.
@@ -52585,9 +51401,9 @@
 
 <ul>
 <li>A (possibly empty) sequence of whitespace characters.  Which characters
 are whitespace is determined by the <code>isspace</code> function
-(see <a href="#Classification%20of%20Characters">Classification of Characters</a>).  These are discarded.
+(see <a href="#Classification of Characters">Classification of Characters</a>).  These are discarded.
 
 <li>An optional plus or minus sign (<code>+</code> or <code>-</code>).
 
 <li>A floating point number in decimal or hexadecimal format.  The
@@ -52595,9 +51411,9 @@
 <ul>
 
 <li>A nonempty sequence of digits optionally containing a decimal-point
 character--normally <code>.</code>, but it depends on the locale
-(see <a href="#General%20Numeric">General Numeric</a>).
+(see <a href="#General Numeric">General Numeric</a>).
 
 <li>An optional exponent part, consisting of a character <code>e</code> or
 <code>E</code>, an optional sign, and a sequence of digits.
 
@@ -52607,9 +51423,9 @@
 <ul>
 
 <li>A 0x or 0X followed by a nonempty sequence of hexadecimal digits
 optionally containing a decimal-point character--normally <code>.</code>, but
-it depends on the locale (see <a href="#General%20Numeric">General Numeric</a>).
+it depends on the locale (see <a href="#General Numeric">General Numeric</a>).
 
 <li>An optional binary-exponent part, consisting of a character <code>p</code> or
 <code>P</code>, an optional sign, and a sequence of digits.
 
@@ -52630,9 +51446,9 @@
 this function may recognize additional locale-dependent syntax.
 
 <p>If the string has valid syntax for a floating-point number but the value
 is outside the range of a <code>double</code>, <code>strtod</code> will signal
-overflow or underflow as described in <a href="#Math%20Error%20Reporting">Math Error Reporting</a>.
+overflow or underflow as described in <a href="#Math Error Reporting">Math Error Reporting</a>.
 
 <p><code>strtod</code> recognizes four special input strings.  The strings
 <code>"inf"</code> and <code>"infinity"</code> are converted to &amp;infin;,
 or to the largest representable value if the floating-point format
@@ -52650,25 +51466,24 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">float <b>strtof</b><i> (const char *<var>string</var>, char **<var>tailptr</var>)
-</i></td>
+<td align="left"><code>float <b>strtof</b><i> (const char *<var>string</var>, char **<var>tailptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>strtold</b><i> (const char *<var>string</var>, char **<var>tailptr</var>)
-</i></td>
+<td align="left"><code>long double <b>strtold</b><i> (const char *<var>string</var>, char **<var>tailptr</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 These functions are analogous to <code>strtod</code>, but return <code>float</code>
 and <code>long double</code> values respectively.  They report errors in the
 same way as <code>strtod</code>.  <code>strtof</code> can be substantially faster
@@ -52680,34 +51495,33 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>wcstod</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>)
-</i></td>
+<td align="left"><code>double <b>wcstod</b><i> (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">float <b>wcstof</b><i> (const wchar_t *<var>string</var>, wchar_t **<var>tailptr</var>)
-</i></td>
+<td align="left"><code>float <b>wcstof</b><i> (const wchar_t *<var>string</var>, wchar_t **<var>tailptr</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">long double <b>wcstold</b><i> (const wchar_t *<var>string</var>, wchar_t **<var>tailptr</var>)
-</i></td>
+<td align="left"><code>long double <b>wcstold</b><i> (const wchar_t *<var>string</var>, wchar_t **<var>tailptr</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcstod</code>, <code>wcstof</code>, and <code>wcstol</code> functions are
 equivalent in nearly all aspect to the <code>strtod</code>, <code>strtof</code>, and
 <code>strtold</code> functions but it handles wide character string.
@@ -52717,16 +51531,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>atof</b><i> (const char *<var>string</var>)
-</i></td>
+<td align="left"><code>double <b>atof</b><i> (const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to the <code>strtod</code> function, except that it
 need not detect overflow and underflow errors.  The <code>atof</code> function
 is provided mostly for compatibility with existing code; using
@@ -52735,13 +51548,13 @@
 </table>
 
 <p>The GNU C library also provides <code>_l</code> versions of these functions,
 which take an additional argument, the locale to use in conversion. 
-See <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+See <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <p><hr>
-Node:<a name="System%20V%20Number%20Conversion">System V Number Conversion</a>,
-Previous:<a rel=previous accesskey=p href="#Parsing%20of%20Numbers">Parsing of Numbers</a>,
+Node:<a name="System V Number Conversion">System V Number Conversion</a>,
+Previous:<a rel=previous accesskey=p href="#Parsing of Numbers">Parsing of Numbers</a>,
 Up:<a rel=up accesskey=u href="#Arithmetic">Arithmetic</a>
 <br>
 
 <h3>Old-fashioned System V number-to-string functions</h3>
@@ -52756,16 +51569,15 @@
 
 <p>All these functions are defined in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ecvt</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)
-</i></td>
+<td align="left"><code>char * <b>ecvt</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>ecvt</code> converts the floating-point number <var>value</var>
 to a string with at most <var>ndigit</var> decimal digits.  The
 returned string contains no decimal point or sign. The first digit of
@@ -52789,16 +51601,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>fcvt</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)
-</i></td>
+<td align="left"><code>char * <b>fcvt</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The function <code>fcvt</code> is like <code>ecvt</code>, but <var>ndigit</var> specifies
 the number of digits after the decimal point.  If <var>ndigit</var> is less
 than zero, <var>value</var> is rounded to the <var>ndigit</var>+1'th place to the
@@ -52815,16 +51626,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>gcvt</b><i> (double <var>value</var>, int <var>ndigit</var>, char *<var>buf</var>)
-</i></td>
+<td align="left"><code>char * <b>gcvt</b><i> (double <var>value</var>, int <var>ndigit</var>, char *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>gcvt</code> is functionally equivalent to <code>sprintf(buf, "%*g",
 ndigit, value</code>.  It is provided only for compatibility's sake.  It
 returns <var>buf</var>.
@@ -52837,48 +51647,45 @@
 <p>As extensions, the GNU C library provides versions of these three
 functions that take <code>long double</code> arguments.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>qecvt</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)
-</i></td>
+<td align="left"><code>char * <b>qecvt</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is equivalent to <code>ecvt</code> except that it takes a
 <code>long double</code> for the first parameter and that <var>ndigit</var> is
 restricted by the precision of a <code>long double</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>qfcvt</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)
-</i></td>
+<td align="left"><code>char * <b>qfcvt</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is equivalent to <code>fcvt</code> except that it
 takes a <code>long double</code> for the first parameter and that <var>ndigit</var> is
 restricted by the precision of a <code>long double</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>qgcvt</b><i> (long double <var>value</var>, int <var>ndigit</var>, char *<var>buf</var>)
-</i></td>
+<td align="left"><code>char * <b>qgcvt</b><i> (long double <var>value</var>, int <var>ndigit</var>, char *<var>buf</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is equivalent to <code>gcvt</code> except that it takes a
 <code>long double</code> for the first parameter and that <var>ndigit</var> is
 restricted by the precision of a <code>long double</code>. 
@@ -52895,16 +51702,15 @@
 <p><code>gcvt_r</code> is not necessary, because <code>gcvt</code> already uses a
 user-supplied buffer.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ecvt_r</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>char * <b>ecvt_r</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ecvt_r</code> function is the same as <code>ecvt</code>, except
 that it places its result into the user-specified buffer pointed to by
 <var>buf</var>, with length <var>len</var>.
@@ -52913,16 +51719,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>fcvt_r</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>char * <b>fcvt_r</b><i> (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fcvt_r</code> function is the same as <code>fcvt</code>, except
 that it places its result into the user-specified buffer pointed to by
 <var>buf</var>, with length <var>len</var>.
@@ -52931,16 +51736,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>qecvt_r</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>char * <b>qecvt_r</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>qecvt_r</code> function is the same as <code>qecvt</code>, except
 that it places its result into the user-specified buffer pointed to by
 <var>buf</var>, with length <var>len</var>.
@@ -52949,16 +51753,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>qfcvt_r</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>char * <b>qfcvt_r</b><i> (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>qfcvt_r</code> function is the same as <code>qfcvt</code>, except
 that it places its result into the user-specified buffer pointed to by
 <var>buf</var>, with length <var>len</var>.
@@ -52967,10 +51770,10 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Date%20and%20Time">Date and Time</a>,
-Next:<a rel=next accesskey=n href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>,
+Node:<a name="Date and Time">Date and Time</a>,
+Next:<a rel=next accesskey=n href="#Resource Usage And Limitation">Resource Usage And Limitation</a>,
 Previous:<a rel=previous accesskey=p href="#Arithmetic">Arithmetic</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -52980,20 +51783,20 @@
 including functions for determining what time it is and conversion
 between different time representations.
 
 <ul>
-<li><a accesskey=1 href="#Time%20Basics">Time Basics</a>:                  Concepts and definitions. 
-<li><a accesskey=2 href="#Elapsed%20Time">Elapsed Time</a>:                 Data types to represent elapsed times
-<li><a accesskey=3 href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>:       Time a program has spent executing. 
-<li><a accesskey=4 href="#Calendar%20Time">Calendar Time</a>:                Manipulation of ``real'' dates and times. 
-<li><a accesskey=5 href="#Setting%20an%20Alarm">Setting an Alarm</a>:             Sending a signal after a specified time. 
+<li><a accesskey=1 href="#Time Basics">Time Basics</a>:                  Concepts and definitions. 
+<li><a accesskey=2 href="#Elapsed Time">Elapsed Time</a>:                 Data types to represent elapsed times
+<li><a accesskey=3 href="#Processor And CPU Time">Processor And CPU Time</a>:       Time a program has spent executing. 
+<li><a accesskey=4 href="#Calendar Time">Calendar Time</a>:                Manipulation of "real" dates and times. 
+<li><a accesskey=5 href="#Setting an Alarm">Setting an Alarm</a>:             Sending a signal after a specified time. 
 <li><a accesskey=6 href="#Sleeping">Sleeping</a>:                     Waiting for a period of time. 
 </ul>
 
 <p><hr>
-Node:<a name="Time%20Basics">Time Basics</a>,
-Next:<a rel=next accesskey=n href="#Elapsed%20Time">Elapsed Time</a>,
-Up:<a rel=up accesskey=u href="#Date%20and%20Time">Date and Time</a>
+Node:<a name="Time Basics">Time Basics</a>,
+Next:<a rel=next accesskey=n href="#Elapsed Time">Elapsed Time</a>,
+Up:<a rel=up accesskey=u href="#Date and Time">Date and Time</a>
 <br>
 
 <h3>Time Basics</h3>
 
@@ -53037,12 +51840,12 @@
 this CPU time, but we reserve the latter term in this manual for the
 definition above.
 
 <p><hr>
-Node:<a name="Elapsed%20Time">Elapsed Time</a>,
-Next:<a rel=next accesskey=n href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>,
-Previous:<a rel=previous accesskey=p href="#Time%20Basics">Time Basics</a>,
-Up:<a rel=up accesskey=u href="#Date%20and%20Time">Date and Time</a>
+Node:<a name="Elapsed Time">Elapsed Time</a>,
+Next:<a rel=next accesskey=n href="#Processor And CPU Time">Processor And CPU Time</a>,
+Previous:<a rel=previous accesskey=p href="#Time Basics">Time Basics</a>,
+Up:<a rel=up accesskey=u href="#Date and Time">Date and Time</a>
 <br>
 
 <h3>Elapsed Time</h3>
 
@@ -53050,16 +51853,15 @@
 type, as with the following function to compute the elapsed time between
 two calendar times.  This function is declared in <code>time.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">double <b>difftime</b><i> (time_t <var>time1</var>, time_t <var>time0</var>)
-</i></td>
+<td align="left"><code>double <b>difftime</b><i> (time_t <var>time1</var>, time_t <var>time0</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>difftime</code> function returns the number of seconds of elapsed
 time between calendar time <var>time1</var> and calendar time <var>time0</var>, as
 a value of type <code>double</code>.  The difference ignores leap seconds
@@ -53077,16 +51879,15 @@
 except that one has a resolution in microseconds, and the other, newer
 one, is in nanoseconds.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct timeval</b><i>
-</i></td>
+<td align="left"><code><b>struct timeval</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>struct timeval</code> structure represents an elapsed time.  It is
 declared in <code>sys/time.h</code> and has the following members:
 
@@ -53103,16 +51904,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct timespec</b><i>
-</i></td>
+<td align="left"><code><b>struct timespec</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>struct timespec</code> structure represents an elapsed time.  It is
 declared in <code>time.h</code> and has the following members:
 
@@ -53132,9 +51932,9 @@
 <p>It is often necessary to subtract two values of type <code>struct&nbsp;timeval</code> or <code>struct&nbsp;timespec</code>.  Here is the best way to do
 this.  It works even on some peculiar operating systems where the
 <code>tv_sec</code> member has an unsigned type.
 
-<br><pre>/* Subtract the `struct timeval' values X and Y,
+<br><pre>/* Subtract the 'struct timeval' values X and Y,
    storing the result in RESULT.
    Return 1 if the difference is negative, otherwise 0.  */
 
 int
@@ -53170,12 +51970,12 @@
 dealing with elapsed times, but the calendar time, processor time, and
 alarm and sleeping functions have a lot to do with them.
 
 <p><hr>
-Node:<a name="Processor%20And%20CPU%20Time">Processor And CPU Time</a>,
-Next:<a rel=next accesskey=n href="#Calendar%20Time">Calendar Time</a>,
-Previous:<a rel=previous accesskey=p href="#Elapsed%20Time">Elapsed Time</a>,
-Up:<a rel=up accesskey=u href="#Date%20and%20Time">Date and Time</a>
+Node:<a name="Processor And CPU Time">Processor And CPU Time</a>,
+Next:<a rel=next accesskey=n href="#Calendar Time">Calendar Time</a>,
+Previous:<a rel=previous accesskey=p href="#Elapsed Time">Elapsed Time</a>,
+Up:<a rel=up accesskey=u href="#Date and Time">Date and Time</a>
 <br>
 
 <h3>Processor And CPU Time</h3>
 
@@ -53184,9 +51984,9 @@
 calendar time and elapsed times are useless because a process may spend
 time waiting for I/O or for other processes to use the CPU.  However,
 you can get the information with the functions in this section.
 
-<p>CPU time (see <a href="#Time%20Basics">Time Basics</a>) is represented by the data type
+<p>CPU time (see <a href="#Time Basics">Time Basics</a>) is represented by the data type
 <code>clock_t</code>, which is a number of <dfn>clock ticks</dfn>.  It gives the
 total amount of time a process has actively used a CPU since some
 arbitrary event.  On the GNU system, that event is the creation of the
 process.  While arbitrary in general, the event is always the same event
@@ -53206,19 +52006,19 @@
 <code>CLOCKS_PER_SEC</code> set to one million this function will return the
 same value approximately every 72 minutes.
 
 <p>For additional functions to examine a process' use of processor time,
-and to control it, See <a href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>.
+and to control it, See <a href="#Resource Usage And Limitation">Resource Usage And Limitation</a>.
 
 <ul>
-<li><a accesskey=1 href="#CPU%20Time">CPU Time</a>:                     The <code>clock</code> function. 
-<li><a accesskey=2 href="#Processor%20Time">Processor Time</a>:               The <code>times</code> function. 
+<li><a accesskey=1 href="#CPU Time">CPU Time</a>:                     The <code>clock</code> function. 
+<li><a accesskey=2 href="#Processor Time">Processor Time</a>:               The <code>times</code> function. 
 </ul>
 
 <p><hr>
-Node:<a name="CPU%20Time">CPU Time</a>,
-Next:<a rel=next accesskey=n href="#Processor%20Time">Processor Time</a>,
-Up:<a rel=up accesskey=u href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>
+Node:<a name="CPU Time">CPU Time</a>,
+Next:<a rel=next accesskey=n href="#Processor Time">Processor Time</a>,
+Up:<a rel=up accesskey=u href="#Processor And CPU Time">Processor And CPU Time</a>
 <br>
 
 <h4>CPU Time Inquiry</h4>
 
@@ -53242,98 +52042,93 @@
 </pre>
 
 <p>Do not use a single CPU time as an amount of time; it doesn't work that
 way.  Either do a subtraction as shown above or query processor time
-directly.  See <a href="#Processor%20Time">Processor Time</a>.
+directly.  See <a href="#Processor Time">Processor Time</a>.
 
 <p>Different computers and operating systems vary wildly in how they keep
 track of CPU time.  It's common for the internal processor clock
 to have a resolution somewhere between a hundredth and millionth of a
 second.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>CLOCKS_PER_SEC</b><i>
-</i></td>
+<td align="left"><code>int <b>CLOCKS_PER_SEC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is the number of clock ticks per second measured
 by the <code>clock</code> function.  POSIX requires that this value be one
 million independent of the actual resolution. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>CLK_TCK</b><i>
-</i></td>
+<td align="left"><code>int <b>CLK_TCK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an obsolete name for <code>CLOCKS_PER_SEC</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>clock_t</b><i>
-</i></td>
+<td align="left"><code><b>clock_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the type of the value returned by the <code>clock</code> function. 
 Values of type <code>clock_t</code> are numbers of clock ticks. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">clock_t <b>clock</b><i> (void)
-</i></td>
+<td align="left"><code>clock_t <b>clock</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the calling process' current CPU time.  If the CPU
 time is not available or cannot be represented, <code>clock</code> returns the
 value <code>(clock_t)(-1)</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Processor%20Time">Processor Time</a>,
-Previous:<a rel=previous accesskey=p href="#CPU%20Time">CPU Time</a>,
-Up:<a rel=up accesskey=u href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>
+Node:<a name="Processor Time">Processor Time</a>,
+Previous:<a rel=previous accesskey=p href="#CPU Time">CPU Time</a>,
+Up:<a rel=up accesskey=u href="#Processor And CPU Time">Processor And CPU Time</a>
 <br>
 
 <h4>Processor Time Inquiry</h4>
 
 <p>The <code>times</code> function returns information about a process'
 consumption of processor time in a <code>struct&nbsp;tms</code> object, in
-addition to the process' CPU time.  See <a href="#Time%20Basics">Time Basics</a>.  You should
+addition to the process' CPU time.  See <a href="#Time Basics">Time Basics</a>.  You should
 include the header file <code>sys/times.h</code> to use this facility.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct tms</b><i>
-</i></td>
+<td align="left"><code><b>struct tms</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>tms</code> structure is used to return information about process
 times.  It contains at least the following members:
 
@@ -53349,9 +52144,9 @@
 <br><dt><code>clock_t tms_cutime</code>
 <dd>This is the sum of the <code>tms_utime</code> values and the <code>tms_cutime</code>
 values of all terminated child processes of the calling process, whose
 status has been reported to the parent process by <code>wait</code> or
-<code>waitpid</code>; see <a href="#Process%20Completion">Process Completion</a>.  In other words, it
+<code>waitpid</code>; see <a href="#Process Completion">Process Completion</a>.  In other words, it
 represents the total processor time used in executing the instructions
 of all the terminated child processes of the calling process, excluding
 child processes which have not yet been reported by <code>wait</code> or
 <code>waitpid</code>.
@@ -53363,21 +52158,20 @@
 </dl>
 
 <p>All of the times are given in numbers of clock ticks.  Unlike CPU time,
 these are the actual amounts of time; not relative to any event. 
-See <a href="#Creating%20a%20Process">Creating a Process</a>. 
+See <a href="#Creating a Process">Creating a Process</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">clock_t <b>times</b><i> (struct tms *<var>buffer</var>)
-</i></td>
+<td align="left"><code>clock_t <b>times</b><i> (struct tms *<var>buffer</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>times</code> function stores the processor time information for
 the calling process in <var>buffer</var>.
 
@@ -53387,24 +52181,24 @@
 </td></tr>
 </table>
 
 <p><strong>Portability Note:</strong> The <code>clock</code> function described in
-<a href="#CPU%20Time">CPU Time</a> is specified by the ISO&nbsp;C standard.  The
+<a href="#CPU Time">CPU Time</a> is specified by the ISO&nbsp;C standard.  The
 <code>times</code> function is a feature of POSIX.1.  In the GNU system, the
 CPU time is defined to be equivalent to the sum of the <code>tms_utime</code>
 and <code>tms_stime</code> fields returned by <code>times</code>.
 
 <p><hr>
-Node:<a name="Calendar%20Time">Calendar Time</a>,
-Next:<a rel=next accesskey=n href="#Setting%20an%20Alarm">Setting an Alarm</a>,
-Previous:<a rel=previous accesskey=p href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>,
-Up:<a rel=up accesskey=u href="#Date%20and%20Time">Date and Time</a>
+Node:<a name="Calendar Time">Calendar Time</a>,
+Next:<a rel=next accesskey=n href="#Setting an Alarm">Setting an Alarm</a>,
+Previous:<a rel=previous accesskey=p href="#Processor And CPU Time">Processor And CPU Time</a>,
+Up:<a rel=up accesskey=u href="#Date and Time">Date and Time</a>
 <br>
 
 <h3>Calendar Time</h3>
 
 <p>This section describes facilities for keeping track of calendar time. 
-See <a href="#Time%20Basics">Time Basics</a>.
+See <a href="#Time Basics">Time Basics</a>.
 
 <p>The GNU C library represents calendar time three ways:
 
 <ul>
@@ -53425,25 +52219,25 @@
 communicate with people. 
 </ul>
 
 <ul>
-<li><a accesskey=1 href="#Simple%20Calendar%20Time">Simple Calendar Time</a>:         Facilities for manipulating calendar time. 
-<li><a accesskey=2 href="#High-Resolution%20Calendar">High-Resolution Calendar</a>:     A time representation with greater precision. 
-<li><a accesskey=3 href="#Broken-down%20Time">Broken-down Time</a>:             Facilities for manipulating local time. 
-<li><a accesskey=4 href="#High%20Accuracy%20Clock">High Accuracy Clock</a>:          Maintaining a high accuracy system clock. 
-<li><a accesskey=5 href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>:     Converting times to strings. 
-<li><a accesskey=6 href="#Parsing%20Date%20and%20Time">Parsing Date and Time</a>:        Convert textual time and date information back
+<li><a accesskey=1 href="#Simple Calendar Time">Simple Calendar Time</a>:         Facilities for manipulating calendar time. 
+<li><a accesskey=2 href="#High-Resolution Calendar">High-Resolution Calendar</a>:     A time representation with greater precision. 
+<li><a accesskey=3 href="#Broken-down Time">Broken-down Time</a>:             Facilities for manipulating local time. 
+<li><a accesskey=4 href="#High Accuracy Clock">High Accuracy Clock</a>:          Maintaining a high accuracy system clock. 
+<li><a accesskey=5 href="#Formatting Calendar Time">Formatting Calendar Time</a>:     Converting times to strings. 
+<li><a accesskey=6 href="#Parsing Date and Time">Parsing Date and Time</a>:        Convert textual time and date information back
                                  into broken-down time values. 
-<li><a accesskey=7 href="#TZ%20Variable">TZ Variable</a>:                  How users specify the time zone. 
-<li><a accesskey=8 href="#Time%20Zone%20Functions">Time Zone Functions</a>:          Functions to examine or specify the time zone. 
-<li><a accesskey=9 href="#Time%20Functions%20Example">Time Functions Example</a>:       An example program showing use of some of
+<li><a accesskey=7 href="#TZ Variable">TZ Variable</a>:                  How users specify the time zone. 
+<li><a accesskey=8 href="#Time Zone Functions">Time Zone Functions</a>:          Functions to examine or specify the time zone. 
+<li><a accesskey=9 href="#Time Functions Example">Time Functions Example</a>:       An example program showing use of some of
 				 the time functions. 
 </ul>
 
 <p><hr>
-Node:<a name="Simple%20Calendar%20Time">Simple Calendar Time</a>,
-Next:<a rel=next accesskey=n href="#High-Resolution%20Calendar">High-Resolution Calendar</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="Simple Calendar Time">Simple Calendar Time</a>,
+Next:<a rel=next accesskey=n href="#High-Resolution Calendar">High-Resolution Calendar</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>Simple Calendar Time</h4>
 
@@ -53451,24 +52245,23 @@
 time as simple time, and the functions which operate on simple time objects. 
 These facilities are declared in the header file <code>time.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>time_t</b><i>
-</i></td>
+<td align="left"><code><b>time_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type used to represent simple time.  Sometimes, it also
 represents an elapsed time.  When interpreted as a calendar time value,
 it represents the number of seconds elapsed since 00:00:00 on January 1,
 1970, Coordinated Universal Time.  (This calendar time is sometimes
 referred to as the <dfn>epoch</dfn>.)  POSIX requires that this count not
 include leap seconds, but on some systems this count includes leap seconds
-if you set <code>TZ</code> to certain values (see <a href="#TZ%20Variable">TZ Variable</a>).
+if you set <code>TZ</code> to certain values (see <a href="#TZ Variable">TZ Variable</a>).
 
 <p>Note that a simple time has no concept of local time zone.  Calendar
 Time <var>T</var> is the same instant in time regardless of where on the
 globe the computer is.
@@ -53480,19 +52273,18 @@
 </table>
 
 <p>The function <code>difftime</code> tells you the elapsed time between two
 simple calendar times, which is not always as easy to compute as just
-subtracting.  See <a href="#Elapsed%20Time">Elapsed Time</a>.
+subtracting.  See <a href="#Elapsed Time">Elapsed Time</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">time_t <b>time</b><i> (time_t *<var>result</var>)
-</i></td>
+<td align="left"><code>time_t <b>time</b><i> (time_t *<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>time</code> function returns the current calendar time as a value of
 type <code>time_t</code>.  If the argument <var>result</var> is not a null pointer,
 the calendar time value is also stored in <code>*<var>result</var></code>.  If the
@@ -53501,24 +52293,23 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>stime</b><i> (time_t *<var>newtime</var>)
-</i></td>
+<td align="left"><code>int <b>stime</b><i> (time_t *<var>newtime</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>stime</code> sets the system clock, i.e.  it tells the system that the
 current calendar time is <var>newtime</var>, where <code>newtime</code> is
 interpreted as described in the above definition of <code>time_t</code>.
 
 <p><code>settimeofday</code> is a newer function which sets the system clock to
 better than one second precision.  <code>settimeofday</code> is generally a
-better choice than <code>stime</code>.  See <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.
+better choice than <code>stime</code>.  See <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.
 
 <p>Only the superuser can set the system clock.
 
 <p>If the function succeeds, the return value is zero.  Otherwise, it is
@@ -53531,12 +52322,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="High-Resolution%20Calendar">High-Resolution Calendar</a>,
-Next:<a rel=next accesskey=n href="#Broken-down%20Time">Broken-down Time</a>,
-Previous:<a rel=previous accesskey=p href="#Simple%20Calendar%20Time">Simple Calendar Time</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="High-Resolution Calendar">High-Resolution Calendar</a>,
+Next:<a rel=next accesskey=n href="#Broken-down Time">Broken-down Time</a>,
+Previous:<a rel=previous accesskey=p href="#Simple Calendar Time">Simple Calendar Time</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>High-Resolution Calendar</h4>
 
@@ -53548,16 +52339,15 @@
 functions and the associated data types described in this section are
 declared in <code>sys/time.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct timezone</b><i>
-</i></td>
+<td align="left"><code><b>struct timezone</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>struct timezone</code> structure is used to hold minimal information
 about the local time zone.  It has the following members:
 
@@ -53569,25 +52359,24 @@
 <dd>If nonzero, Daylight Saving Time applies during some part of the year. 
 </dl>
 
 <p>The <code>struct timezone</code> type is obsolete and should never be used. 
-Instead, use the facilities described in <a href="#Time%20Zone%20Functions">Time Zone Functions</a>. 
+Instead, use the facilities described in <a href="#Time Zone Functions">Time Zone Functions</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>gettimeofday</b><i> (struct timeval *<var>tp</var>, struct timezone *<var>tzp</var>)
-</i></td>
+<td align="left"><code>int <b>gettimeofday</b><i> (struct timeval *<var>tp</var>, struct timezone *<var>tzp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gettimeofday</code> function returns the current calendar time as
 the elapsed time since the epoch in the <code>struct timeval</code> structure
-indicated by <var>tp</var>.  (see <a href="#Elapsed%20Time">Elapsed Time</a> for a description of
+indicated by <var>tp</var>.  (see <a href="#Elapsed Time">Elapsed Time</a> for a description of
 <code>struct timespec</code>).  Information about the time zone is returned in
 the structure pointed at <var>tzp</var>.  If the <var>tzp</var> argument is a null
 pointer, time zone information is ignored.
 
@@ -53599,22 +52388,21 @@
 <dd>The operating system does not support getting time zone information, and
 <var>tzp</var> is not a null pointer.  The GNU operating system does not
 support using <code>struct&nbsp;timezone</code> to represent time zone
 information; that is an obsolete feature of 4.3 BSD. 
-Instead, use the facilities described in <a href="#Time%20Zone%20Functions">Time Zone Functions</a>. 
+Instead, use the facilities described in <a href="#Time Zone Functions">Time Zone Functions</a>. 
 </dl>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>settimeofday</b><i> (const struct timeval *<var>tp</var>, const struct timezone *<var>tzp</var>)
-</i></td>
+<td align="left"><code>int <b>settimeofday</b><i> (const struct timeval *<var>tp</var>, const struct timezone *<var>tzp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>settimeofday</code> function sets the current calendar time in the
 system clock according to the arguments.  As for <code>gettimeofday</code>,
 the calendar time is represented as the elapsed time since the epoch. 
@@ -53653,16 +52441,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>adjtime</b><i> (const struct timeval *<var>delta</var>, struct timeval *<var>olddelta</var>)
-</i></td>
+<td align="left"><code>int <b>adjtime</b><i> (const struct timeval *<var>delta</var>, struct timeval *<var>olddelta</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function speeds up or slows down the system clock in order to make
 a gradual adjustment.  This ensures that the calendar time reported by
 the system clock is always monotonically increasing, which might not
@@ -53698,31 +52485,30 @@
 
 <p>Symbols for the following function are declared in <code>sys/timex.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>adjtimex</b><i> (struct timex *<var>timex</var>)
-</i></td>
+<td align="left"><code>int <b>adjtimex</b><i> (struct timex *<var>timex</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>adjtimex</code> is functionally identical to <code>ntp_adjtime</code>. 
-See <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>.
+See <a href="#High Accuracy Clock">High Accuracy Clock</a>.
 
 <p>This function is present only with a Linux kernel.
 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Broken-down%20Time">Broken-down Time</a>,
-Next:<a rel=next accesskey=n href="#High%20Accuracy%20Clock">High Accuracy Clock</a>,
-Previous:<a rel=previous accesskey=p href="#High-Resolution%20Calendar">High-Resolution Calendar</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="Broken-down Time">Broken-down Time</a>,
+Next:<a rel=next accesskey=n href="#High Accuracy Clock">High Accuracy Clock</a>,
+Previous:<a rel=previous accesskey=p href="#High-Resolution Calendar">High-Resolution Calendar</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>Broken-down Time</h4>
 
@@ -53739,16 +52525,15 @@
 
 <p>The symbols in this section are declared in the header file <code>time.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct tm</b><i>
-</i></td>
+<td align="left"><code><b>struct tm</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the data type used to represent a broken-down time.  The structure
 contains at least the following members, which can appear in any order.
 
@@ -53811,16 +52596,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct tm * <b>localtime</b><i> (const time_t *<var>time</var>)
-</i></td>
+<td align="left"><code>struct tm * <b>localtime</b><i> (const time_t *<var>time</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>localtime</code> function converts the simple time pointed to by
 <var>time</var> to broken-down time representation, expressed relative to the
 user's specified time zone.
@@ -53834,25 +52618,24 @@
 as a broken-down time; typically this is because the year cannot fit into
 an <code>int</code>.
 
 <p>Calling <code>localtime</code> has one other effect: it sets the variable
-<code>tzname</code> with information about the current time zone.  See <a href="#Time%20Zone%20Functions">Time Zone Functions</a>. 
+<code>tzname</code> with information about the current time zone.  See <a href="#Time Zone Functions">Time Zone Functions</a>. 
 </td></tr>
 </table>
 
 <p>Using the <code>localtime</code> function is a big problem in multi-threaded
 programs.  The result is returned in a static buffer and this is used in
 all threads.  POSIX.1c introduced a variant of this function.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct tm * <b>localtime_r</b><i> (const time_t *<var>time</var>, struct tm *<var>resultp</var>)
-</i></td>
+<td align="left"><code>struct tm * <b>localtime_r</b><i> (const time_t *<var>time</var>, struct tm *<var>resultp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>localtime_r</code> function works just like the <code>localtime</code>
 function.  It takes a pointer to a variable containing a simple time
 and converts it to the broken-down time format.
@@ -53866,16 +52649,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct tm * <b>gmtime</b><i> (const time_t *<var>time</var>)
-</i></td>
+<td align="left"><code>struct tm * <b>gmtime</b><i> (const time_t *<var>time</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>localtime</code>, except that the broken-down
 time is expressed as Coordinated Universal Time (UTC) (formerly called
 Greenwich Mean Time (GMT)) rather than relative to a local time zone.
@@ -53887,16 +52669,15 @@
 is placed in a static variable.  POSIX.1c also provides a replacement for
 <code>gmtime</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct tm * <b>gmtime_r</b><i> (const time_t *<var>time</var>, struct tm *<var>resultp</var>)
-</i></td>
+<td align="left"><code>struct tm * <b>gmtime_r</b><i> (const time_t *<var>time</var>, struct tm *<var>resultp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>localtime_r</code>, except that it converts
 just like <code>gmtime</code> the given time as Coordinated Universal Time.
 
@@ -53905,16 +52686,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">time_t <b>mktime</b><i> (struct tm *<var>brokentime</var>)
-</i></td>
+<td align="left"><code>time_t <b>mktime</b><i> (struct tm *<var>brokentime</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>mktime</code> function is used to convert a broken-down time structure
 to a simple time representation.  It also "normalizes" the contents of
 the broken-down time structure, by filling in the day of week and day of
@@ -53932,21 +52712,20 @@
 <code>mktime</code> returns a value of <code>(time_t)(-1)</code> and does not modify
 the contents of <var>brokentime</var>.
 
 <p>Calling <code>mktime</code> also sets the variable <code>tzname</code> with
-information about the current time zone.  See <a href="#Time%20Zone%20Functions">Time Zone Functions</a>. 
+information about the current time zone.  See <a href="#Time Zone Functions">Time Zone Functions</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">time_t <b>timelocal</b><i> (struct tm *<var>brokentime</var>)
-</i></td>
+<td align="left"><code>time_t <b>timelocal</b><i> (struct tm *<var>brokentime</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>timelocal</code> is functionally identical to <code>mktime</code>, but more
 mnemonically named.  Note that it is the inverse of the <code>localtime</code>
@@ -53958,16 +52737,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">time_t <b>timegm</b><i> (struct tm *<var>brokentime</var>)
-</i></td>
+<td align="left"><code>time_t <b>timegm</b><i> (struct tm *<var>brokentime</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>timegm</code> is functionally identical to <code>mktime</code> except it
 always takes the input values to be Coordinated Universal Time (UTC)
@@ -53984,12 +52762,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="High%20Accuracy%20Clock">High Accuracy Clock</a>,
-Next:<a rel=next accesskey=n href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>,
-Previous:<a rel=previous accesskey=p href="#Broken-down%20Time">Broken-down Time</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="High Accuracy Clock">High Accuracy Clock</a>,
+Next:<a rel=next accesskey=n href="#Formatting Calendar Time">Formatting Calendar Time</a>,
+Previous:<a rel=previous accesskey=p href="#Broken-down Time">Broken-down Time</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>High Accuracy Clock</h4>
 
@@ -54004,24 +52782,23 @@
 
 <p>These functions are declared in <code>sys/timex.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct ntptimeval</b><i>
-</i></td>
+<td align="left"><code><b>struct ntptimeval</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used for information about the system clock.  It
 contains the following members:
 <dl>
 <dt><code>struct timeval time</code>
 <dd>This is the current calendar time, expressed as the elapsed time since
 the epoch.  The <code>struct timeval</code> data type is described in
-<a href="#Elapsed%20Time">Elapsed Time</a>.
+<a href="#Elapsed Time">Elapsed Time</a>.
 
 <br><dt><code>long int maxerror</code>
 <dd>This is the maximum error, measured in microseconds.  Unless updated
 via <code>ntp_adjtime</code> periodically, this value will reach some
@@ -54035,16 +52812,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ntp_gettime</b><i> (struct ntptimeval *<var>tptr</var>)
-</i></td>
+<td align="left"><code>int <b>ntp_gettime</b><i> (struct ntptimeval *<var>tptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ntp_gettime</code> function sets the structure pointed to by
 <var>tptr</var> to current values.  The elements of the structure afterwards
 contain the values the timer implementation in the kernel assumes.  They
@@ -54063,16 +52839,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct timex</b><i>
-</i></td>
+<td align="left"><code><b>struct timex</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used to control and monitor the system clock.  It
 contains the following members:
 <dl>
@@ -54168,16 +52943,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ntp_adjtime</b><i> (struct timex *<var>tptr</var>)
-</i></td>
+<td align="left"><code>int <b>ntp_adjtime</b><i> (struct timex *<var>tptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ntp_adjtime</code> function sets the structure specified by
 <var>tptr</var> to current values.
 
@@ -54215,28 +52989,27 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Formatting%20Calendar%20Time">Formatting Calendar Time</a>,
-Next:<a rel=next accesskey=n href="#Parsing%20Date%20and%20Time">Parsing Date and Time</a>,
-Previous:<a rel=previous accesskey=p href="#High%20Accuracy%20Clock">High Accuracy Clock</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="Formatting Calendar Time">Formatting Calendar Time</a>,
+Next:<a rel=next accesskey=n href="#Parsing Date and Time">Parsing Date and Time</a>,
+Previous:<a rel=previous accesskey=p href="#High Accuracy Clock">High Accuracy Clock</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>Formatting Calendar Time</h4>
 
 <p>The functions described in this section format calendar time values as
 strings.  These functions are declared in the header file <code>time.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>asctime</b><i> (const struct tm *<var>brokentime</var>)
-</i></td>
+<td align="left"><code>char * <b>asctime</b><i> (const struct tm *<var>brokentime</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>asctime</code> function converts the broken-down time value that
 <var>brokentime</var> points to into a string in a standard format:
 
@@ -54257,16 +53030,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>asctime_r</b><i> (const struct tm *<var>brokentime</var>, char *<var>buffer</var>)
-</i></td>
+<td align="left"><code>char * <b>asctime_r</b><i> (const struct tm *<var>brokentime</var>, char *<var>buffer</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>asctime</code> but instead of placing the
 result in a static buffer it writes the string in the buffer pointed to
 by the parameter <var>buffer</var>.  This buffer should have room
@@ -54278,16 +53050,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ctime</b><i> (const time_t *<var>time</var>)
-</i></td>
+<td align="left"><code>char * <b>ctime</b><i> (const time_t *<var>time</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ctime</code> function is similar to <code>asctime</code>, except that you
 specify the calendar time argument as a <code>time_t</code> simple time value
 rather than in broken-down local time format.  It is equivalent to
@@ -54295,25 +53066,24 @@
 <br><pre>asctime (localtime (<var>time</var>))
 </pre>
 
 <p><code>ctime</code> sets the variable <code>tzname</code>, because <code>localtime</code>
-does so.  See <a href="#Time%20Zone%20Functions">Time Zone Functions</a>. 
+does so.  See <a href="#Time Zone Functions">Time Zone Functions</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ctime_r</b><i> (const time_t *<var>time</var>, char *<var>buffer</var>)
-</i></td>
+<td align="left"><code>char * <b>ctime_r</b><i> (const time_t *<var>time</var>, char *<var>buffer</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>ctime</code>, but places the result in the
 string pointed to by <var>buffer</var>.  It is equivalent to (written using
-gcc extensions, see <a href="gcc.html#Statement%20Exprs">Statement Exprs</a>):
+gcc extensions, see <a href="gcc.html#Statement Exprs">Statement Exprs</a>):
 
 <br><pre>({ struct tm tm; asctime_r (localtime_r (time, &amp;tm), buf); })
 </pre>
 
@@ -54323,18 +53093,17 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>strftime</b><i> (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, const struct tm *<var>brokentime</var>)
-</i></td>
+<td align="left"><code>size_t <b>strftime</b><i> (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, const struct tm *<var>brokentime</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-This function is similar to the <code>sprintf</code> function (see <a href="#Formatted%20Input">Formatted Input</a>), but the conversion specifications that can appear in the format
+This function is similar to the <code>sprintf</code> function (see <a href="#Formatted Input">Formatted Input</a>), but the conversion specifications that can appear in the format
 template <var>template</var> are specialized for printing components of the date
 and time <var>brokentime</var> according to the locale currently specified for
 time conversion (see <a href="#Locales">Locales</a>).
 
@@ -54357,9 +53126,9 @@
 with spaces.
 
 <br><dt><code>^</code>
 <dd>The output uses uppercase characters, but only if this is possible
-(see <a href="#Case%20Conversion">Case Conversion</a>). 
+(see <a href="#Case Conversion">Case Conversion</a>). 
 </dl>
 
 <p>The default action is to pad the number with zeros to keep it a constant
 width.  Numbers that do not have a range indicated below are never
@@ -54637,21 +53406,20 @@
 <p>According to POSIX.1 every call to <code>strftime</code> implies a call to
 <code>tzset</code>.  So the contents of the environment variable <code>TZ</code>
 is examined before any output is produced.
 
-<p>For an example of <code>strftime</code>, see <a href="#Time%20Functions%20Example">Time Functions Example</a>. 
+<p>For an example of <code>strftime</code>, see <a href="#Time Functions Example">Time Functions Example</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>wcsftime</b><i> (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, const struct tm *<var>brokentime</var>)
-</i></td>
+<td align="left"><code>size_t <b>wcsftime</b><i> (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, const struct tm *<var>brokentime</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>wcsftime</code> function is equivalent to the <code>strftime</code>
 function with the difference that it operates on wide character
 strings.  The buffer where the result is stored, pointed to by <var>s</var>,
@@ -54675,12 +53443,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Parsing%20Date%20and%20Time">Parsing Date and Time</a>,
-Next:<a rel=next accesskey=n href="#TZ%20Variable">TZ Variable</a>,
-Previous:<a rel=previous accesskey=p href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="Parsing Date and Time">Parsing Date and Time</a>,
+Next:<a rel=next accesskey=n href="#TZ Variable">TZ Variable</a>,
+Previous:<a rel=previous accesskey=p href="#Formatting Calendar Time">Formatting Calendar Time</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>Convert textual time and date information back</h4>
 
@@ -54692,17 +53460,17 @@
 <code>getdate</code>.  Both have strange interfaces but at least they are
 widely available.
 
 <ul>
-<li><a accesskey=1 href="#Low-Level%20Time%20String%20Parsing">Low-Level Time String Parsing</a>:   Interpret string according to given format. 
-<li><a accesskey=2 href="#General%20Time%20String%20Parsing">General Time String Parsing</a>:     User-friendly function to parse data and
+<li><a accesskey=1 href="#Low-Level Time String Parsing">Low-Level Time String Parsing</a>:   Interpret string according to given format. 
+<li><a accesskey=2 href="#General Time String Parsing">General Time String Parsing</a>:     User-friendly function to parse data and
                                     time strings. 
 </ul>
 
 <p><hr>
-Node:<a name="Low-Level%20Time%20String%20Parsing">Low-Level Time String Parsing</a>,
-Next:<a rel=next accesskey=n href="#General%20Time%20String%20Parsing">General Time String Parsing</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20Date%20and%20Time">Parsing Date and Time</a>
+Node:<a name="Low-Level Time String Parsing">Low-Level Time String Parsing</a>,
+Next:<a rel=next accesskey=n href="#General Time String Parsing">General Time String Parsing</a>,
+Up:<a rel=up accesskey=u href="#Parsing Date and Time">Parsing Date and Time</a>
 <br>
 
 <h5>Interpret string according to given format</h5>
 
@@ -54711,16 +53479,15 @@
 implementation are heavily influenced by the <code>getdate</code> function,
 which is defined and implemented in terms of calls to <code>strptime</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strptime</b><i> (const char *<var>s</var>, const char *<var>fmt</var>, struct tm *<var>tp</var>)
-</i></td>
+<td align="left"><code>char * <b>strptime</b><i> (const char *<var>s</var>, const char *<var>fmt</var>, struct tm *<var>tp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>strptime</code> function parses the input string <var>s</var> according
 to the format string <var>fmt</var> and stores its results in the
 structure <var>tp</var>.
@@ -55082,11 +53849,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="General%20Time%20String%20Parsing">General Time String Parsing</a>,
-Previous:<a rel=previous accesskey=p href="#Low-Level%20Time%20String%20Parsing">Low-Level Time String Parsing</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20Date%20and%20Time">Parsing Date and Time</a>
+Node:<a name="General Time String Parsing">General Time String Parsing</a>,
+Previous:<a rel=previous accesskey=p href="#Low-Level Time String Parsing">Low-Level Time String Parsing</a>,
+Up:<a rel=up accesskey=u href="#Parsing Date and Time">Parsing Date and Time</a>
 <br>
 
 <h5>A More User-friendly Way to Parse Times and Dates</h5>
 
@@ -55097,16 +53864,15 @@
 a static variable, and uses a global variable and global state (an
 environment variable).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>getdate_err</b><i>
-</i></td>
+<td align="left"><code><b>getdate_err</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This variable of type <code>int</code> contains the error code of the last
 unsuccessful call to <code>getdate</code>.  Defined values are:
 
@@ -55134,16 +53900,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct tm * <b>getdate</b><i> (const char *<var>string</var>)
-</i></td>
+<td align="left"><code>struct tm * <b>getdate</b><i> (const char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The interface to <code>getdate</code> is the simplest possible for a function
 to parse a string and return the value.  <var>string</var> is the input
 string and the result is returned in a statically-allocated variable.
@@ -55246,16 +54011,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getdate_r</b><i> (const char *<var>string</var>, struct tm *<var>tp</var>)
-</i></td>
+<td align="left"><code>int <b>getdate_r</b><i> (const char *<var>string</var>, struct tm *<var>tp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getdate_r</code> function is the reentrant counterpart of
 <code>getdate</code>.  It does not use the global variable <code>getdate_err</code>
 to signal an error, but instead returns an error code.  The same error
@@ -55274,19 +54038,19 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="TZ%20Variable">TZ Variable</a>,
-Next:<a rel=next accesskey=n href="#Time%20Zone%20Functions">Time Zone Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Parsing%20Date%20and%20Time">Parsing Date and Time</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="TZ Variable">TZ Variable</a>,
+Next:<a rel=next accesskey=n href="#Time Zone Functions">Time Zone Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Parsing Date and Time">Parsing Date and Time</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>Specifying the Time Zone with <code>TZ</code></h4>
 
 <p>In POSIX systems, a user can specify the time zone by means of the
 <code>TZ</code> environment variable.  For information about how to set
-environment variables, see <a href="#Environment%20Variables">Environment Variables</a>.  The functions
+environment variables, see <a href="#Environment Variables">Environment Variables</a>.  The functions
 for accessing the time zone are declared in <code>time.h</code>.
 
 <p>You should not normally need to set <code>TZ</code>.  If the system is
 configured properly, the default time zone will be correct.  You might
@@ -55416,25 +54180,24 @@
 information for most regions of the world, which is maintained by a
 community of volunteers and put in the public domain.
 
 <p><hr>
-Node:<a name="Time%20Zone%20Functions">Time Zone Functions</a>,
-Next:<a rel=next accesskey=n href="#Time%20Functions%20Example">Time Functions Example</a>,
-Previous:<a rel=previous accesskey=p href="#TZ%20Variable">TZ Variable</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="Time Zone Functions">Time Zone Functions</a>,
+Next:<a rel=next accesskey=n href="#Time Functions Example">Time Functions Example</a>,
+Previous:<a rel=previous accesskey=p href="#TZ Variable">TZ Variable</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>Functions and Variables for Time Zones</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>tzname</b><i> [2]
-</i></td>
+<td align="left"><code>char * <b>tzname</b><i> [2]</i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The array <code>tzname</code> contains two strings, which are the standard
 names of the pair of time zones (standard and Daylight
 Saving) that the user has selected.  <code>tzname[0]</code> is the name of
@@ -55463,16 +54226,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>tzset</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>tzset</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>tzset</code> function initializes the <code>tzname</code> variable from
 the value of the <code>TZ</code> environment variable.  It is not usually
 necessary for your program to call this function, because it is called
@@ -55485,16 +54247,15 @@
 Unix.  Like <code>tzname</code>, these variables are set by calling
 <code>tzset</code> or the other time conversion functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>timezone</b><i>
-</i></td>
+<td align="left"><code>long int <b>timezone</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This contains the difference between UTC and the latest local standard
 time, in seconds west of UTC.  For example, in the U.S. Eastern time
 zone, the value is <code>5*60*60</code>.  Unlike the <code>tm_gmtoff</code> member
@@ -55505,16 +54266,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>daylight</b><i>
-</i></td>
+<td align="left"><code>int <b>daylight</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This variable has a nonzero value if Daylight Saving Time rules apply. 
 A nonzero value does not necessarily mean that Daylight Saving Time is
 now in effect; it means only that Daylight Saving Time is sometimes in
@@ -55522,11 +54282,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Time%20Functions%20Example">Time Functions Example</a>,
-Previous:<a rel=previous accesskey=p href="#Time%20Zone%20Functions">Time Zone Functions</a>,
-Up:<a rel=up accesskey=u href="#Calendar%20Time">Calendar Time</a>
+Node:<a name="Time Functions Example">Time Functions Example</a>,
+Previous:<a rel=previous accesskey=p href="#Time Zone Functions">Time Zone Functions</a>,
+Up:<a rel=up accesskey=u href="#Calendar Time">Calendar Time</a>
 <br>
 
 <h4>Time Functions Example</h4>
 
@@ -55573,12 +54333,12 @@
 The time is 01:02 PM.
 </pre>
 
 <p><hr>
-Node:<a name="Setting%20an%20Alarm">Setting an Alarm</a>,
+Node:<a name="Setting an Alarm">Setting an Alarm</a>,
 Next:<a rel=next accesskey=n href="#Sleeping">Sleeping</a>,
-Previous:<a rel=previous accesskey=p href="#Calendar%20Time">Calendar Time</a>,
-Up:<a rel=up accesskey=u href="#Date%20and%20Time">Date and Time</a>
+Previous:<a rel=previous accesskey=p href="#Calendar Time">Calendar Time</a>,
+Up:<a rel=up accesskey=u href="#Date and Time">Date and Time</a>
 <br>
 
 <h3>Setting an Alarm</h3>
 
@@ -55612,24 +54372,23 @@
 <code>signal</code> or <code>sigaction</code> before issuing a call to
 <code>setitimer</code> or <code>alarm</code>.  Otherwise, an unusual chain of events
 could cause the timer to expire before your program establishes the
 handler.  In this case it would be terminated, since termination is the
-default action for the alarm signals.  See <a href="#Signal%20Handling">Signal Handling</a>.
+default action for the alarm signals.  See <a href="#Signal Handling">Signal Handling</a>.
 
 <p>The <code>setitimer</code> function is the primary means for setting an alarm. 
 This facility is declared in the header file <code>sys/time.h</code>.  The
 <code>alarm</code> function, declared in <code>unistd.h</code>, provides a somewhat
 simpler interface for setting the real-time timer.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct itimerval</b><i>
-</i></td>
+<td align="left"><code><b>struct itimerval</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used to specify when a timer should expire.  It contains
 the following members:
 <dl>
@@ -55641,21 +54400,20 @@
 <dd>This is the period between now and the first timer interrupt.  If zero,
 the alarm is disabled. 
 </dl>
 
-<p>The <code>struct timeval</code> data type is described in <a href="#Elapsed%20Time">Elapsed Time</a>. 
+<p>The <code>struct timeval</code> data type is described in <a href="#Elapsed Time">Elapsed Time</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setitimer</b><i> (int <var>which</var>, struct itimerval *<var>new</var>, struct itimerval *<var>old</var>)
-</i></td>
+<td align="left"><code>int <b>setitimer</b><i> (int <var>which</var>, struct itimerval *<var>new</var>, struct itimerval *<var>old</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>setitimer</code> function sets the timer specified by <var>which</var>
 according to <var>new</var>.  The <var>which</var> argument can have a value of
 <code>ITIMER_REAL</code>, <code>ITIMER_VIRTUAL</code>, or <code>ITIMER_PROF</code>.
@@ -55674,16 +54432,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getitimer</b><i> (int <var>which</var>, struct itimerval *<var>old</var>)
-</i></td>
+<td align="left"><code>int <b>getitimer</b><i> (int <var>which</var>, struct itimerval *<var>old</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getitimer</code> function stores information about the timer specified
 by <var>which</var> in the structure pointed at by <var>old</var>.
 
@@ -55708,16 +54465,15 @@
 timer. 
 </dl>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned int <b>alarm</b><i> (unsigned int <var>seconds</var>)
-</i></td>
+<td align="left"><code>unsigned int <b>alarm</b><i> (unsigned int <var>seconds</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>alarm</code> function sets the real-time timer to expire in
 <var>seconds</var> seconds.  If you want to cancel any existing alarm, you
 can do this by calling <code>alarm</code> with a <var>seconds</var> argument of
@@ -55747,9 +54503,9 @@
 }
 </pre>
 
 <p>There is an example showing the use of the <code>alarm</code> function in
-<a href="#Handler%20Returns">Handler Returns</a>.
+<a href="#Handler Returns">Handler Returns</a>.
 
 <p>If you simply want your process to wait for a given number of seconds,
 you should use the <code>sleep</code> function.  See <a href="#Sleeping">Sleeping</a>.
 
@@ -55763,10 +54519,10 @@
 <code>alarm</code>, but <code>alarm</code> is more widely used.
 
 <p><hr>
 Node:<a name="Sleeping">Sleeping</a>,
-Previous:<a rel=previous accesskey=p href="#Setting%20an%20Alarm">Setting an Alarm</a>,
-Up:<a rel=up accesskey=u href="#Date%20and%20Time">Date and Time</a>
+Previous:<a rel=previous accesskey=p href="#Setting an Alarm">Setting an Alarm</a>,
+Up:<a rel=up accesskey=u href="#Date and Time">Date and Time</a>
 <br>
 
 <h3>Sleeping</h3>
 
@@ -55774,20 +54530,19 @@
 for a short interval.  If your program doesn't use signals (except to
 terminate), then you can expect <code>sleep</code> to wait reliably throughout
 the specified interval.  Otherwise, <code>sleep</code> can return sooner if a
 signal arrives; if you want to wait for a given interval regardless of
-signals, use <code>select</code> (see <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>) and don't specify
+signals, use <code>select</code> (see <a href="#Waiting for I%2fO">Waiting for I/O</a>) and don't specify
 any descriptors to wait for.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned int <b>sleep</b><i> (unsigned int <var>seconds</var>)
-</i></td>
+<td align="left"><code>unsigned int <b>sleep</b><i> (unsigned int <var>seconds</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sleep</code> function waits for <var>seconds</var> or until a signal
 is delivered, whichever happens first.
 
@@ -55830,16 +54585,15 @@
 the same program, because <code>sleep</code> does not work by means of
 <code>SIGALRM</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>nanosleep</b><i> (const struct timespec *<var>requested_time</var>, struct timespec *<var>remaining</var>)
-</i></td>
+<td align="left"><code>int <b>nanosleep</b><i> (const struct timespec *<var>requested_time</var>, struct timespec *<var>remaining</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If resolution to seconds is not enough the <code>nanosleep</code> function can
 be used.  As the name suggests the sleep interval can be specified in
 nanoseconds.  The actual elapsed time of the sleep interval might be
@@ -55852,9 +54606,9 @@
 <p>The function returns as *<code>remaining</code> the elapsed time left in the
 interval for which you requested to sleep.  If the interval completed
 without getting interrupted by a signal, this is zero.
 
-<p><code>struct timespec</code> is described in See <a href="#Elapsed%20Time">Elapsed Time</a>.
+<p><code>struct timespec</code> is described in See <a href="#Elapsed Time">Elapsed Time</a>.
 
 <p>If the function returns because the interval is over the return value is
 zero.  If the function returns -1 the global variable <var>errno</var>
 is set to the following values:
@@ -55883,11 +54637,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>,
-Next:<a rel=next accesskey=n href="#Non-Local%20Exits">Non-Local Exits</a>,
-Previous:<a rel=previous accesskey=p href="#Date%20and%20Time">Date and Time</a>,
+Node:<a name="Resource Usage And Limitation">Resource Usage And Limitation</a>,
+Next:<a rel=next accesskey=n href="#Non-Local Exits">Non-Local Exits</a>,
+Previous:<a rel=previous accesskey=p href="#Date and Time">Date and Time</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Resource Usage And Limitation</h2>
@@ -55896,19 +54650,19 @@
 resources (CPU time, memory, etc.) a process has used and getting and setting
 limits on future usage.
 
 <ul>
-<li><a accesskey=1 href="#Resource%20Usage">Resource Usage</a>: 		Measuring various resources used. 
-<li><a accesskey=2 href="#Limits%20on%20Resources">Limits on Resources</a>: 		Specifying limits on resource usage. 
+<li><a accesskey=1 href="#Resource Usage">Resource Usage</a>: 		Measuring various resources used. 
+<li><a accesskey=2 href="#Limits on Resources">Limits on Resources</a>: 		Specifying limits on resource usage. 
 <li><a accesskey=3 href="#Priority">Priority</a>: 			Reading or setting process run priority. 
-<li><a accesskey=4 href="#Memory%20Resources">Memory Resources</a>:             Querying memory available resources. 
-<li><a accesskey=5 href="#Processor%20Resources">Processor Resources</a>:          Learn about the processors available. 
+<li><a accesskey=4 href="#Memory Resources">Memory Resources</a>:             Querying memory available resources. 
+<li><a accesskey=5 href="#Processor Resources">Processor Resources</a>:          Learn about the processors available. 
 </ul>
 
 <p><hr>
-Node:<a name="Resource%20Usage">Resource Usage</a>,
-Next:<a rel=next accesskey=n href="#Limits%20on%20Resources">Limits on Resources</a>,
-Up:<a rel=up accesskey=u href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>
+Node:<a name="Resource Usage">Resource Usage</a>,
+Next:<a rel=next accesskey=n href="#Limits on Resources">Limits on Resources</a>,
+Up:<a rel=up accesskey=u href="#Resource Usage And Limitation">Resource Usage And Limitation</a>
 <br>
 
 <h3>Resource Usage</h3>
 
@@ -55916,16 +54670,15 @@
 are used to examine the resource usage of a process.  They are declared
 in <code>sys/resource.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getrusage</b><i> (int <var>processes</var>, struct rusage *<var>rusage</var>)
-</i></td>
+<td align="left"><code>int <b>getrusage</b><i> (int <var>processes</var>, struct rusage *<var>rusage</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reports resource usage totals for processes specified by
 <var>processes</var>, storing the information in <code>*<var>rusage</var></code>.
 
@@ -55953,19 +54706,18 @@
 </table>
 
 <p>One way of getting resource usage for a particular child process is with
 the function <code>wait4</code>, which returns totals for a child when it
-terminates.  See <a href="#BSD%20Wait%20Functions">BSD Wait Functions</a>.
+terminates.  See <a href="#BSD Wait Functions">BSD Wait Functions</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct rusage</b><i>
-</i></td>
+<td align="left"><code><b>struct rusage</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type stores various resource usage statistics.  It has the
 following members, and possibly others:
 
@@ -56038,16 +54790,15 @@
 <p><code>vtimes</code> and its <code>vtimes</code> data structure are declared in
 <code>sys/vtimes.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vtimes</b><i> (struct vtimes <var>current</var>, struct vtimes <var>child</var>)
-</i></td>
+<td align="left"><code>int <b>vtimes</b><i> (struct vtimes <var>current</var>, struct vtimes <var>child</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>vtimes</code> reports resource usage totals for a process.
 
@@ -56057,16 +54808,15 @@
 past children (which have terminated) of the invoking process in the structure
 to which it points.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct vtimes</b><i>
-</i></td>
+<td align="left"><code><b>struct vtimes</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type contains information about the resource usage of a process. 
 Each member corresponds to a member of the <code>struct rusage</code> data type
 described above.
@@ -56106,12 +54856,12 @@
 <code>vtimes</code>, is supported but not documented here.  It is declared in
 <code>sys/vtimes.h</code>.
 
 <p><hr>
-Node:<a name="Limits%20on%20Resources">Limits on Resources</a>,
+Node:<a name="Limits on Resources">Limits on Resources</a>,
 Next:<a rel=next accesskey=n href="#Priority">Priority</a>,
-Previous:<a rel=previous accesskey=p href="#Resource%20Usage">Resource Usage</a>,
-Up:<a rel=up accesskey=u href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>
+Previous:<a rel=previous accesskey=p href="#Resource Usage">Resource Usage</a>,
+Up:<a rel=up accesskey=u href="#Resource Usage And Limitation">Resource Usage And Limitation</a>
 <br>
 
 <h3>Limiting Resource Usage</h3>
 
@@ -56141,16 +54891,15 @@
 <code>getrlimit64</code>, and <code>setrlimit64</code> are defined in
 <code>sys/resource.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getrlimit</b><i> (int <var>resource</var>, struct rlimit *<var>rlp</var>)
-</i></td>
+<td align="left"><code>int <b>getrlimit</b><i> (int <var>resource</var>, struct rlimit *<var>rlp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Read the current and maximum limits for the resource <var>resource</var>
 and store them in <code>*<var>rlp</var></code>.
 
@@ -56163,16 +54912,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getrlimit64</b><i> (int <var>resource</var>, struct rlimit64 *<var>rlp</var>)
-</i></td>
+<td align="left"><code>int <b>getrlimit64</b><i> (int <var>resource</var>, struct rlimit64 *<var>rlp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getrlimit</code> but its second parameter is
 a pointer to a variable of type <code>struct rlimit64</code>, which allows it
 to read values which wouldn't fit in the member of a <code>struct
@@ -56184,16 +54932,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setrlimit</b><i> (int <var>resource</var>, const struct rlimit *<var>rlp</var>)
-</i></td>
+<td align="left"><code>int <b>setrlimit</b><i> (int <var>resource</var>, const struct rlimit *<var>rlp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Store the current and maximum limits for the resource <var>resource</var>
 in <code>*<var>rlp</var></code>.
 
@@ -56216,16 +54963,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setrlimit64</b><i> (int <var>resource</var>, const struct rlimit64 *<var>rlp</var>)
-</i></td>
+<td align="left"><code>int <b>setrlimit64</b><i> (int <var>resource</var>, const struct rlimit64 *<var>rlp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>setrlimit</code> but its second parameter is
 a pointer to a variable of type <code>struct rlimit64</code> which allows it
 to set values which wouldn't fit in the member of a <code>struct
@@ -56237,16 +54983,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct rlimit</b><i>
-</i></td>
+<td align="left"><code><b>struct rlimit</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used with <code>getrlimit</code> to receive limit values,
 and with <code>setrlimit</code> to specify limit values for a particular process
 and resource.  It has two fields:
@@ -56266,16 +55011,15 @@
 
 <p>For the LFS functions a similar type is defined in <code>sys/resource.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct rlimit64</b><i>
-</i></td>
+<td align="left"><code><b>struct rlimit64</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is analogous to the <code>rlimit</code> structure above, but
 its components have wider ranges.  It has two fields:
 
@@ -56296,13 +55040,13 @@
 <dl>
 <dt><code>RLIMIT_CPU</code>
 <dd>The maximum amount of CPU time the process can use.  If it runs for
 longer than this, it gets a signal: <code>SIGXCPU</code>.  The value is
-measured in seconds.  See <a href="#Operation%20Error%20Signals">Operation Error Signals</a>.
+measured in seconds.  See <a href="#Operation Error Signals">Operation Error Signals</a>.
 
 <br><dt><code>RLIMIT_FSIZE</code>
 <dd>The maximum size of file the process can create.  Trying to write a
-larger file causes a signal: <code>SIGXFSZ</code>.  See <a href="#Operation%20Error%20Signals">Operation Error Signals</a>.
+larger file causes a signal: <code>SIGXFSZ</code>.  See <a href="#Operation Error Signals">Operation Error Signals</a>.
 
 <br><dt><code>RLIMIT_DATA</code>
 <dd>The maximum size of data memory for the process.  If the process tries
 to allocate data memory beyond this amount, the allocation function
@@ -56310,9 +55054,9 @@
 
 <br><dt><code>RLIMIT_STACK</code>
 <dd>The maximum stack size for the process.  If the process tries to extend
 its stack past this size, it gets a <code>SIGSEGV</code> signal. 
-See <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+See <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>RLIMIT_CORE</code>
 <dd>The maximum size core file that this process can create.  If the process
 terminates and would dump a core file larger than this, then no core
@@ -56331,15 +55075,15 @@
 
 <br><dt><code>RLIMIT_NPROC</code>
 <dd>The maximum number of processes that can be created with the same user ID. 
 If you have reached the limit for your user ID, <code>fork</code> will fail
-with <code>EAGAIN</code>.  See <a href="#Creating%20a%20Process">Creating a Process</a>.
+with <code>EAGAIN</code>.  See <a href="#Creating a Process">Creating a Process</a>.
 
 <br><dt><code>RLIMIT_NOFILE</code>
 <dt><code>RLIMIT_OFILE</code>
 <dd>The maximum number of files that the process can open.  If it tries to
 open more files than this, its open attempt fails with <code>errno</code>
-<code>EMFILE</code>.  See <a href="#Error%20Codes">Error Codes</a>.  Not all systems support this limit;
+<code>EMFILE</code>.  See <a href="#Error Codes">Error Codes</a>.  Not all systems support this limit;
 GNU does, and 4.4 BSD does.
 
 <br><dt><code>RLIMIT_AS</code>
 <dd>The maximum size of total memory that this process should get.  If the
@@ -56352,16 +55096,15 @@
 operand must be less than <code>RLIM_NLIMITS</code>. 
 </dl>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>RLIM_INFINITY</b><i>
-</i></td>
+<td align="left"><code>int <b>RLIM_INFINITY</b><i></i></code></td>
 <td align="right">Constant</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant stands for a value of "infinity" when supplied as
 the limit value in <code>setrlimit</code>. 
 </td></tr>
@@ -56372,16 +55115,15 @@
 
 <p><code>ulimit</code> and the command symbols are declared in <code>ulimit.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ulimit</b><i> (int <var>cmd</var>, ...)
-</i></td>
+<td align="left"><code>int <b>ulimit</b><i> (int <var>cmd</var>, ...)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>ulimit</code> gets the current limit or sets the current and maximum
 limit for a particular resource for the calling process according to the
@@ -56424,16 +55166,15 @@
 
 <p><code>vlimit</code> and its resource symbols are declared in <code>sys/vlimit.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>vlimit</b><i> (int <var>resource</var>, int <var>limit</var>)
-</i></td>
+<td align="left"><code>int <b>vlimit</b><i> (int <var>resource</var>, int <var>limit</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>vlimit</code> sets the current limit for a resource for a process.
 
@@ -56466,11 +55207,11 @@
 </table>
 
 <p><hr>
 Node:<a name="Priority">Priority</a>,
-Next:<a rel=next accesskey=n href="#Memory%20Resources">Memory Resources</a>,
-Previous:<a rel=previous accesskey=p href="#Limits%20on%20Resources">Limits on Resources</a>,
-Up:<a rel=up accesskey=u href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>
+Next:<a rel=next accesskey=n href="#Memory Resources">Memory Resources</a>,
+Previous:<a rel=previous accesskey=p href="#Limits on Resources">Limits on Resources</a>,
+Up:<a rel=up accesskey=u href="#Resource Usage And Limitation">Resource Usage And Limitation</a>
 <br>
 
 <h3>Process CPU Priority And Scheduling</h3>
 
@@ -56508,17 +55249,17 @@
 the Linux implementation is quite the inverse of what the authors of the
 POSIX syntax had in mind.
 
 <ul>
-<li><a accesskey=1 href="#Absolute%20Priority">Absolute Priority</a>:                The first tier of priority.  Posix
-<li><a accesskey=2 href="#Realtime%20Scheduling">Realtime Scheduling</a>:              Scheduling among the process nobility
-<li><a accesskey=3 href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>:       Get/set scheduling policy, priority
-<li><a accesskey=4 href="#Traditional%20Scheduling">Traditional Scheduling</a>:           Scheduling among the vulgar masses
+<li><a accesskey=1 href="#Absolute Priority">Absolute Priority</a>:                The first tier of priority.  Posix
+<li><a accesskey=2 href="#Realtime Scheduling">Realtime Scheduling</a>:              Scheduling among the process nobility
+<li><a accesskey=3 href="#Basic Scheduling Functions">Basic Scheduling Functions</a>:       Get/set scheduling policy, priority
+<li><a accesskey=4 href="#Traditional Scheduling">Traditional Scheduling</a>:           Scheduling among the vulgar masses
 </ul>
 
 <p><hr>
-Node:<a name="Absolute%20Priority">Absolute Priority</a>,
-Next:<a rel=next accesskey=n href="#Realtime%20Scheduling">Realtime Scheduling</a>,
+Node:<a name="Absolute Priority">Absolute Priority</a>,
+Next:<a rel=next accesskey=n href="#Realtime Scheduling">Realtime Scheduling</a>,
 Up:<a rel=up accesskey=u href="#Priority">Priority</a>
 <br>
 
 <h4>Absolute Priority</h4>
@@ -56527,9 +55268,9 @@
 The higher the number, the higher the absolute priority.
 
 <p>On systems of the past, and most systems today, all processes have
 absolute priority 0 and this section is irrelevant.  In that case,
-See <a href="#Traditional%20Scheduling">Traditional Scheduling</a>.  Absolute priorities were invented to
+See <a href="#Traditional Scheduling">Traditional Scheduling</a>.  Absolute priorities were invented to
 accommodate realtime systems, in which it is vital that certain processes
 be able to respond to external events happening in real time, which
 means they cannot wait around while some other process that <em>wants
 to</em>, but doesn't <em>need to</em> run occupies the CPU.
@@ -56547,17 +55288,17 @@
 <p>When two processes are running or ready to run and both have the same
 absolute priority, it's more interesting.  In that case, who gets the
 CPU is determined by the scheduling policy.  If the processes have
 absolute priority 0, the traditional scheduling policy described in
-<a href="#Traditional%20Scheduling">Traditional Scheduling</a> applies.  Otherwise, the policies described
-in <a href="#Realtime%20Scheduling">Realtime Scheduling</a> apply.
+<a href="#Traditional Scheduling">Traditional Scheduling</a> applies.  Otherwise, the policies described
+in <a href="#Realtime Scheduling">Realtime Scheduling</a> apply.
 
 <p>You normally give an absolute priority above 0 only to a process that
 can be trusted not to hog the CPU.  Such processes are designed to block
 (or terminate) after relatively short CPU runs.
 
 <p>A process begins life with the same absolute priority as its parent
-process.  Functions described in <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a> can
+process.  Functions described in <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a> can
 change it.
 
 <p>Only a privileged process can change a process' absolute priority to
 something other than <code>0</code>.  Only a privileged process or the
@@ -56617,24 +55358,24 @@
 priority."  We don't use that term in this manual because it misses the
 most important feature of the absolute priority:  its absoluteness.
 
 <p><hr>
-Node:<a name="Realtime%20Scheduling">Realtime Scheduling</a>,
-Next:<a rel=next accesskey=n href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Absolute%20Priority">Absolute Priority</a>,
+Node:<a name="Realtime Scheduling">Realtime Scheduling</a>,
+Next:<a rel=next accesskey=n href="#Basic Scheduling Functions">Basic Scheduling Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Absolute Priority">Absolute Priority</a>,
 Up:<a rel=up accesskey=u href="#Priority">Priority</a>
 <br>
 
 <h4>Realtime Scheduling</h4>
 
 <p>Whenever two processes with the same absolute priority are ready to run,
 the kernel has a decision to make, because only one can run at a time. 
 If the processes have absolute priority 0, the kernel makes this decision
-as described in <a href="#Traditional%20Scheduling">Traditional Scheduling</a>.  Otherwise, the decision
+as described in <a href="#Traditional Scheduling">Traditional Scheduling</a>.  Otherwise, the decision
 is as described in this section.
 
 <p>If two processes are ready to run but have different absolute priorities,
-the decision is much simpler, and is described in <a href="#Absolute%20Priority">Absolute Priority</a>.
+the decision is much simpler, and is described in <a href="#Absolute Priority">Absolute Priority</a>.
 
 <p>Each process has a scheduling policy.  For processes with absolute
 priority other than zero, there are two available:
 
@@ -56688,17 +55429,17 @@
 round robin time slice is a thousand times shorter than its typical
 time slice for traditional scheduling.
 
 <p>A process begins life with the same scheduling policy as its parent process. 
-Functions described in <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a> can change it.
+Functions described in <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a> can change it.
 
 <p>Only a privileged process can set the scheduling policy of a process
 that has absolute priority higher than 0.
 
 <p><hr>
-Node:<a name="Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>,
-Next:<a rel=next accesskey=n href="#Traditional%20Scheduling">Traditional Scheduling</a>,
-Previous:<a rel=previous accesskey=p href="#Realtime%20Scheduling">Realtime Scheduling</a>,
+Node:<a name="Basic Scheduling Functions">Basic Scheduling Functions</a>,
+Next:<a rel=next accesskey=n href="#Traditional Scheduling">Traditional Scheduling</a>,
+Previous:<a rel=previous accesskey=p href="#Realtime Scheduling">Realtime Scheduling</a>,
 Up:<a rel=up accesskey=u href="#Priority">Priority</a>
 <br>
 
 <h4>Basic Scheduling Functions</h4>
@@ -56710,9 +55451,9 @@
 section, the macro _POSIX_PRIORITY_SCHEDULING is defined in
 <code>&lt;unistd.h&gt;</code>.
 
 <p>For the case that the scheduling policy is traditional scheduling, more
-functions to fine tune the scheduling are in <a href="#Traditional%20Scheduling">Traditional Scheduling</a>.
+functions to fine tune the scheduling are in <a href="#Traditional Scheduling">Traditional Scheduling</a>.
 
 <p>Don't try to make too much out of the naming and structure of these
 functions.  They don't match the concepts described in this manual
 because the functions are as defined by POSIX.1b, but the implementation
@@ -56725,16 +55466,15 @@
 
 <p>The symbols in this section are declared by including file <code>sched.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sched_param</b><i>
-</i></td>
+<td align="left"><code><b>struct sched_param</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure describes an absolute priority.
 <dl>
 <dt><code>int sched_priority</code>
@@ -56743,16 +55483,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_setscheduler</b><i> (pid_t <var>pid</var>, int <var>policy</var>, const struct sched_param *<var>param</var>)
-</i></td>
+<td align="left"><code>int <b>sched_setscheduler</b><i> (pid_t <var>pid</var>, int <var>policy</var>, const struct sched_param *<var>param</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function sets both the absolute priority and the scheduling policy
 for a process.
@@ -56812,16 +55551,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_getscheduler</b><i> (pid_t <var>pid</var>)
-</i></td>
+<td align="left"><code>int <b>sched_getscheduler</b><i> (pid_t <var>pid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function returns the scheduling policy assigned to the process with
 Process ID (pid) <var>pid</var>, or the calling process if <var>pid</var> is zero.
@@ -56852,16 +55590,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_setparam</b><i> (pid_t <var>pid</var>, const struct sched_param *<var>param</var>)
-</i></td>
+<td align="left"><code>int <b>sched_setparam</b><i> (pid_t <var>pid</var>, const struct sched_param *<var>param</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function sets a process' absolute priority.
 
@@ -56871,16 +55608,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_getparam</b><i> (pid_t <var>pid</var>, const struct sched_param *<var>param</var>)
-</i></td>
+<td align="left"><code>int <b>sched_getparam</b><i> (pid_t <var>pid</var>, const struct sched_param *<var>param</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function returns a process' absolute priority.
 
@@ -56907,16 +55643,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_get_priority_min</b><i> (int *<var>policy</var>);
-</i></td>
+<td align="left"><code>int <b>sched_get_priority_min</b><i> (int *<var>policy</var>);</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function returns the lowest absolute priority value that is
 allowable for a process with scheduling policy <var>policy</var>.
@@ -56935,16 +55670,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_get_priority_max</b><i> (int *<var>policy</var>);
-</i></td>
+<td align="left"><code>int <b>sched_get_priority_max</b><i> (int *<var>policy</var>);</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function returns the highest absolute priority value that is
 allowable for a process that with scheduling policy <var>policy</var>.
@@ -56963,16 +55697,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_rr_get_interval</b><i> (pid_t <var>pid</var>, struct timespec *<var>interval</var>)
-</i></td>
+<td align="left"><code>int <b>sched_rr_get_interval</b><i> (pid_t <var>pid</var>, struct timespec *<var>interval</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function returns the length of the quantum (time slice) used with
 the Round Robin scheduling policy, if it is used, for the process with
@@ -56991,16 +55724,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sched_yield</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>sched_yield</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>This function voluntarily gives up the process' claim on the CPU.
 
@@ -57028,10 +55760,10 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Traditional%20Scheduling">Traditional Scheduling</a>,
-Previous:<a rel=previous accesskey=p href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>,
+Node:<a name="Traditional Scheduling">Traditional Scheduling</a>,
+Previous:<a rel=previous accesskey=p href="#Basic Scheduling Functions">Basic Scheduling Functions</a>,
 Up:<a rel=up accesskey=u href="#Priority">Priority</a>
 <br>
 
 <h4>Traditional Scheduling</h4>
@@ -57042,21 +55774,21 @@
 taken all they want, the scheduling described herein determines who
 among the great unwashed processes gets them.
 
 <ul>
-<li><a accesskey=1 href="#Traditional%20Scheduling%20Intro">Traditional Scheduling Intro</a>: 
-<li><a accesskey=2 href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>: 
+<li><a accesskey=1 href="#Traditional Scheduling Intro">Traditional Scheduling Intro</a>: 
+<li><a accesskey=2 href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>: 
 </ul>
 
 <p><hr>
-Node:<a name="Traditional%20Scheduling%20Intro">Traditional Scheduling Intro</a>,
-Next:<a rel=next accesskey=n href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>,
-Up:<a rel=up accesskey=u href="#Traditional%20Scheduling">Traditional Scheduling</a>
+Node:<a name="Traditional Scheduling Intro">Traditional Scheduling Intro</a>,
+Next:<a rel=next accesskey=n href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>,
+Up:<a rel=up accesskey=u href="#Traditional Scheduling">Traditional Scheduling</a>
 <br>
 
 <h5>Introduction To Traditional Scheduling</h5>
 
-<p>Long before there was absolute priority (See <a href="#Absolute%20Priority">Absolute Priority</a>),
+<p>Long before there was absolute priority (See <a href="#Absolute Priority">Absolute Priority</a>),
 Unix systems were scheduling the CPU using this system.  When Posix came
 in like the Romans and imposed absolute priorities to accommodate the
 needs of realtime processing, it left the indigenous Absolute Priority
 Zero processes to govern themselves by their own familiar scheduling
@@ -57128,14 +55860,14 @@
 privileged process can lower its nice value.  A privileged process can
 also raise or lower another process' nice value.
 
 <p>GNU C Library functions for getting and setting nice values are described in
-See <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+See <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <p><hr>
-Node:<a name="Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Traditional%20Scheduling%20Intro">Traditional Scheduling Intro</a>,
-Up:<a rel=up accesskey=u href="#Traditional%20Scheduling">Traditional Scheduling</a>
+Node:<a name="Traditional Scheduling Functions">Traditional Scheduling Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Traditional Scheduling Intro">Traditional Scheduling Intro</a>,
+Up:<a rel=up accesskey=u href="#Traditional Scheduling">Traditional Scheduling</a>
 <br>
 
 <h5>Functions For Traditional Scheduling</h5>
 
@@ -57159,16 +55891,15 @@
 <dd>The highest valid nice value. 
 </dl>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpriority</b><i> (int <var>class</var>, int <var>id</var>)
-</i></td>
+<td align="left"><code>int <b>getpriority</b><i> (int <var>class</var>, int <var>id</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Return the nice value of a set of processes; <var>class</var> and <var>id</var>
 specify which ones (see below).  If the processes specified do not all
 have the same nice value, this returns the lowest value that any of them
@@ -57194,16 +55925,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setpriority</b><i> (int <var>class</var>, int <var>id</var>, int <var>niceval</var>)
-</i></td>
+<td align="left"><code>int <b>setpriority</b><i> (int <var>class</var>, int <var>id</var>, int <var>niceval</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Set the nice value of a set of processes to <var>niceval</var>; <var>class</var>
 and <var>id</var> specify which ones (see below).
 
@@ -57253,16 +55983,15 @@
 <p>If the argument <var>id</var> is 0, it stands for the calling process, its
 process group, or its owner (real uid), according to <var>class</var>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>nice</b><i> (int <var>increment</var>)
-</i></td>
+<td align="left"><code>int <b>nice</b><i> (int <var>increment</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Increment the nice value of the calling process by <var>increment</var>. 
 The return value is the new nice value on success, and <code>-1</code> on
 failure.  In the case of failure, <code>errno</code> will be set to the
@@ -57284,12 +56013,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Memory%20Resources">Memory Resources</a>,
-Next:<a rel=next accesskey=n href="#Processor%20Resources">Processor Resources</a>,
+Node:<a name="Memory Resources">Memory Resources</a>,
+Next:<a rel=next accesskey=n href="#Processor Resources">Processor Resources</a>,
 Previous:<a rel=previous accesskey=p href="#Priority">Priority</a>,
-Up:<a rel=up accesskey=u href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>
+Up:<a rel=up accesskey=u href="#Resource Usage And Limitation">Resource Usage And Limitation</a>
 <br>
 
 <h3>Querying memory available resources</h3>
 
@@ -57301,17 +56030,17 @@
 into these details a few words about memory subsystems in traditional
 Unix systems will be given.
 
 <ul>
-<li><a accesskey=1 href="#Memory%20Subsystem">Memory Subsystem</a>:            Overview about traditional Unix memory handling. 
-<li><a accesskey=2 href="#Query%20Memory%20Parameters">Query Memory Parameters</a>:     How to get information about the memory
+<li><a accesskey=1 href="#Memory Subsystem">Memory Subsystem</a>:            Overview about traditional Unix memory handling. 
+<li><a accesskey=2 href="#Query Memory Parameters">Query Memory Parameters</a>:     How to get information about the memory
                                 subsystem? 
 </ul>
 
 <p><hr>
-Node:<a name="Memory%20Subsystem">Memory Subsystem</a>,
-Next:<a rel=next accesskey=n href="#Query%20Memory%20Parameters">Query Memory Parameters</a>,
-Up:<a rel=up accesskey=u href="#Memory%20Resources">Memory Resources</a>
+Node:<a name="Memory Subsystem">Memory Subsystem</a>,
+Next:<a rel=next accesskey=n href="#Query Memory Parameters">Query Memory Parameters</a>,
+Up:<a rel=up accesskey=u href="#Memory Resources">Memory Resources</a>
 <br>
 
 <h4>Overview about traditional Unix memory handling</h4>
 
@@ -57352,18 +56081,18 @@
 of two byte.  The smallest page size in use today is 4096, with 8192,
 16384, and 65536 being other popular sizes.
 
 <p><hr>
-Node:<a name="Query%20Memory%20Parameters">Query Memory Parameters</a>,
-Previous:<a rel=previous accesskey=p href="#Memory%20Subsystem">Memory Subsystem</a>,
-Up:<a rel=up accesskey=u href="#Memory%20Resources">Memory Resources</a>
+Node:<a name="Query Memory Parameters">Query Memory Parameters</a>,
+Previous:<a rel=previous accesskey=p href="#Memory Subsystem">Memory Subsystem</a>,
+Up:<a rel=up accesskey=u href="#Memory Resources">Memory Resources</a>
 <br>
 
 <h4>How to get information about the memory subsystem?</h4>
 
 <p>The page size of the virtual memory the process sees is essential to
 know in several situations.  Some programming interface (e.g.,
-<code>mmap</code>, see <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>) require the user to provide
+<code>mmap</code>, see <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>) require the user to provide
 information adjusted to the page size.  In the case of <code>mmap</code> is it
 necessary to provide a length argument which is a multiple of the page
 size.  Another place where the knowledge about the page size is useful
 is in memory allocation.  If one allocates pieces of memory in larger
@@ -57383,20 +56112,19 @@
 runtime about the current page size and no assumptions (except about it
 being a power of two) should be made.
 
 <p>The correct interface to query about the page size is <code>sysconf</code>
-(see <a href="#Sysconf%20Definition">Sysconf Definition</a>) with the parameter <code>_SC_PAGESIZE</code>. 
+(see <a href="#Sysconf Definition">Sysconf Definition</a>) with the parameter <code>_SC_PAGESIZE</code>. 
 There is a much older interface available, too.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpagesize</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>getpagesize</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getpagesize</code> function returns the page size of the process. 
 This value is fixed for the runtime of the process but can vary in
 different runs of the application.
@@ -57431,16 +56159,15 @@
 <code>sys/sysinfo.h</code>.  Programmers should prefer to use the
 <code>sysconf</code> method described above.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>get_phys_pages</b><i> (void)
-</i></td>
+<td align="left"><code>long int <b>get_phys_pages</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>get_phys_pages</code> function returns the total number of pages of
 physical the system has.  To get the amount of memory this number has to
 be multiplied by the page size.
@@ -57449,16 +56176,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>get_avphys_pages</b><i> (void)
-</i></td>
+<td align="left"><code>long int <b>get_avphys_pages</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>get_phys_pages</code> function returns the number of available pages of
 physical the system has.  To get the amount of memory this number has to
 be multiplied by the page size.
@@ -57467,11 +56193,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Processor%20Resources">Processor Resources</a>,
-Previous:<a rel=previous accesskey=p href="#Memory%20Resources">Memory Resources</a>,
-Up:<a rel=up accesskey=u href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>
+Node:<a name="Processor Resources">Processor Resources</a>,
+Previous:<a rel=previous accesskey=p href="#Memory Resources">Memory Resources</a>,
+Up:<a rel=up accesskey=u href="#Resource Usage And Limitation">Resource Usage And Limitation</a>
 <br>
 
 <h3>Learn about the processors available</h3>
 
@@ -57499,16 +56225,15 @@
 functions to get the information directly.  The functions are declared
 in <code>sys/sysinfo.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>get_nprocs_conf</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>get_nprocs_conf</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>get_nprocs_conf</code> function returns the number of processors the
 operating system configured.
 
@@ -57516,16 +56241,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>get_nprocs</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>get_nprocs</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>get_nprocs</code> function returns the number of available processors.
 
 <p>This function is a GNU extension. 
@@ -57538,16 +56262,15 @@
 running.  This number is average over different periods of times
 (normally 1, 5, and 15 minutes).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getloadavg</b><i> (double <var>loadavg</var>[], int <var>nelem</var>)
-</i></td>
+<td align="left"><code>int <b>getloadavg</b><i> (double <var>loadavg</var>[], int <var>nelem</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function gets the 1, 5 and 15 minute load averages of the
 system. The values are placed in <var>loadavg</var>.  <code>getloadavg</code> will
 place at most <var>nelem</var> elements into the array but never more than
@@ -57558,11 +56281,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Non-Local%20Exits">Non-Local Exits</a>,
-Next:<a rel=next accesskey=n href="#Signal%20Handling">Signal Handling</a>,
-Previous:<a rel=previous accesskey=p href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>,
+Node:<a name="Non-Local Exits">Non-Local Exits</a>,
+Next:<a rel=next accesskey=n href="#Signal Handling">Signal Handling</a>,
+Previous:<a rel=previous accesskey=p href="#Resource Usage And Limitation">Resource Usage And Limitation</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Non-Local Exits</h2>
@@ -57573,18 +56296,18 @@
 do such <dfn>non-local exits</dfn> using the <code>setjmp</code> and <code>longjmp</code>
 functions.
 
 <ul>
-<li><a accesskey=1 href="#Non-Local%20Intro">Intro</a>:         When and how to use these facilities. 
-<li><a accesskey=2 href="#Non-Local%20Details">Details</a>:     Functions for non-local exits. 
-<li><a accesskey=3 href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>:   Portability issues. 
-<li><a accesskey=4 href="#System%20V%20contexts">System V contexts</a>:             Complete context control a la System V. 
+<li><a accesskey=1 href="#Non-Local Intro">Intro</a>:         When and how to use these facilities. 
+<li><a accesskey=2 href="#Non-Local Details">Details</a>:     Functions for non-local exits. 
+<li><a accesskey=3 href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>:   Portability issues. 
+<li><a accesskey=4 href="#System V contexts">System V contexts</a>:             Complete context control a la System V. 
 </ul>
 
 <p><hr>
-Node:<a name="Non-Local%20Intro">Non-Local Intro</a>,
-Next:<a rel=next accesskey=n href="#Non-Local%20Details">Non-Local Details</a>,
-Up:<a rel=up accesskey=u href="#Non-Local%20Exits">Non-Local Exits</a>
+Node:<a name="Non-Local Intro">Non-Local Intro</a>,
+Next:<a rel=next accesskey=n href="#Non-Local Details">Non-Local Details</a>,
+Up:<a rel=up accesskey=u href="#Non-Local Exits">Non-Local Exits</a>
 <br>
 
 <h3>Introduction to Non-Local Exits</h3>
 
@@ -57686,12 +56409,12 @@
   <small>...</small>
 </pre>
 
 <p><hr>
-Node:<a name="Non-Local%20Details">Non-Local Details</a>,
-Next:<a rel=next accesskey=n href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Non-Local%20Intro">Non-Local Intro</a>,
-Up:<a rel=up accesskey=u href="#Non-Local%20Exits">Non-Local Exits</a>
+Node:<a name="Non-Local Details">Non-Local Details</a>,
+Next:<a rel=next accesskey=n href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Non-Local Intro">Non-Local Intro</a>,
+Up:<a rel=up accesskey=u href="#Non-Local Exits">Non-Local Exits</a>
 <br>
 
 <h3>Details of Non-Local Exits</h3>
 
@@ -57699,32 +56422,30 @@
 performing non-local exits.  These facilities are declared in
 <code>setjmp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>jmp_buf</b><i>
-</i></td>
+<td align="left"><code><b>jmp_buf</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Objects of type <code>jmp_buf</code> hold the state information to
 be restored by a non-local exit.  The contents of a <code>jmp_buf</code>
 identify a specific place to return to. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setjmp</b><i> (jmp_buf <var>state</var>)
-</i></td>
+<td align="left"><code>int <b>setjmp</b><i> (jmp_buf <var>state</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 When called normally, <code>setjmp</code> stores information about the
 execution state of the program in <var>state</var> and returns zero.  If
 <code>longjmp</code> is later used to perform a non-local exit to this
@@ -57732,16 +56453,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>longjmp</b><i> (jmp_buf <var>state</var>, int <var>value</var>)
-</i></td>
+<td align="left"><code>void <b>longjmp</b><i> (jmp_buf <var>state</var>, int <var>value</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function restores current execution to the state saved in
 <var>state</var>, and continues execution from the call to <code>setjmp</code> that
 established that return point.  Returning from <code>setjmp</code> by means of
@@ -57793,71 +56513,68 @@
 the call to <code>setjmp</code> are indeterminate, unless you have declared
 them <code>volatile</code>.
 
 <p><hr>
-Node:<a name="Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>,
-Next:<a rel=next accesskey=n href="#System%20V%20contexts">System V contexts</a>,
-Previous:<a rel=previous accesskey=p href="#Non-Local%20Details">Non-Local Details</a>,
-Up:<a rel=up accesskey=u href="#Non-Local%20Exits">Non-Local Exits</a>
+Node:<a name="Non-Local Exits and Signals">Non-Local Exits and Signals</a>,
+Next:<a rel=next accesskey=n href="#System V contexts">System V contexts</a>,
+Previous:<a rel=previous accesskey=p href="#Non-Local Details">Non-Local Details</a>,
+Up:<a rel=up accesskey=u href="#Non-Local Exits">Non-Local Exits</a>
 <br>
 
 <h3>Non-Local Exits and Signals</h3>
 
 <p>In BSD Unix systems, <code>setjmp</code> and <code>longjmp</code> also save and
-restore the set of blocked signals; see <a href="#Blocking%20Signals">Blocking Signals</a>.  However,
+restore the set of blocked signals; see <a href="#Blocking Signals">Blocking Signals</a>.  However,
 the POSIX.1 standard requires <code>setjmp</code> and <code>longjmp</code> not to
 change the set of blocked signals, and provides an additional pair of
 functions (<code>sigsetjmp</code> and <code>siglongjmp</code>) to get the BSD
 behavior.
 
 <p>The behavior of <code>setjmp</code> and <code>longjmp</code> in the GNU library is
-controlled by feature test macros; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.  The
+controlled by feature test macros; see <a href="#Feature Test Macros">Feature Test Macros</a>.  The
 default in the GNU system is the POSIX.1 behavior rather than the BSD
 behavior.
 
 <p>The facilities in this section are declared in the header file
 <code>setjmp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>sigjmp_buf</b><i>
-</i></td>
+<td align="left"><code><b>sigjmp_buf</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>jmp_buf</code>, except that it can also store state
 information about the set of blocked signals. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigsetjmp</b><i> (sigjmp_buf <var>state</var>, int <var>savesigs</var>)
-</i></td>
+<td align="left"><code>int <b>sigsetjmp</b><i> (sigjmp_buf <var>state</var>, int <var>savesigs</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>setjmp</code>.  If <var>savesigs</var> is nonzero, the set
 of blocked signals is saved in <var>state</var> and will be restored if a
 <code>siglongjmp</code> is later performed with this <var>state</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>siglongjmp</b><i> (sigjmp_buf <var>state</var>, int <var>value</var>)
-</i></td>
+<td align="left"><code>void <b>siglongjmp</b><i> (sigjmp_buf <var>state</var>, int <var>value</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>longjmp</code> except for the type of its <var>state</var>
 argument.  If the <code>sigsetjmp</code> call that set this <var>state</var> used a
 nonzero <var>savesigs</var> flag, <code>siglongjmp</code> also restores the set of
@@ -57865,11 +56582,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="System%20V%20contexts">System V contexts</a>,
-Previous:<a rel=previous accesskey=p href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>,
-Up:<a rel=up accesskey=u href="#Non-Local%20Exits">Non-Local Exits</a>
+Node:<a name="System V contexts">System V contexts</a>,
+Previous:<a rel=previous accesskey=p href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>,
+Up:<a rel=up accesskey=u href="#Non-Local Exits">Non-Local Exits</a>
 <br>
 
 <h3>Complete Context Control</h3>
 
@@ -57889,16 +56606,15 @@
 The types and functions described in this section are all defined and
 declared respectively in the <code>ucontext.h</code> header file.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>ucontext_t</b><i>
-</i></td>
+<td align="left"><code><b>ucontext_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>ucontext_t</code> type is defined as a structure with as least the
 following elements:
@@ -57912,9 +56628,9 @@
 <dd>Set of signals which are blocked when this context is used.
 
 <br><dt><code>stack_t uc_stack</code>
 <dd>Stack used for this context.  The value need not be (and normally is
-not) the stack pointer.  See <a href="#Signal%20Stack">Signal Stack</a>.
+not) the stack pointer.  See <a href="#Signal Stack">Signal Stack</a>.
 
 <br><dt><code>mcontext_t uc_mcontext</code>
 <dd>This element contains the actual state of the process.  The
 <code>mcontext_t</code> type is also defined in this header but the definition
@@ -57928,16 +56644,15 @@
 <p>Objects of this type have to be created by the user.  The initialization
 and modification happens through one of the following functions:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getcontext</b><i> (ucontext_t *<var>ucp</var>)
-</i></td>
+<td align="left"><code>int <b>getcontext</b><i> (ucontext_t *<var>ucp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getcontext</code> function initializes the variable pointed to by
 <var>ucp</var> with the context of the calling thread.  The context contains
 the content of the registers, the signal mask, and the current stack. 
@@ -57962,16 +56677,15 @@
 similar constructs.  The <code>makecontext</code> function is what has to be
 used to do that.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>makecontext</b><i> (ucontext_t *<var>ucp</var>, void (*<var>func</var>) (void), int <var>argc</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>makecontext</b><i> (ucontext_t *<var>ucp</var>, void (*<var>func</var>) (void), int <var>argc</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <var>ucp</var> parameter passed to the <code>makecontext</code> shall be
 initialized by a call to <code>getcontext</code>.  The context will be
@@ -58000,9 +56714,9 @@
 programs would fail.  Examples for such code include the calling
 sequences the GNU C compiler generates for calls to nested functions. 
 Safe ways to allocate stacks correctly include using memory on the
 original threads stack or explicitly allocate memory tagged for
-execution using (see <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>).
+execution using (see <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>).
 
 <p><strong>Compatibility note</strong>: The current Unix standard is very imprecise
 about the way the stack is allocated.  All implementations seem to agree
 that the <code>uc_stack</code> element must be used but the values stored in
@@ -58016,16 +56730,15 @@
 difference makes the <code>makecontext</code> function hard to use and it
 requires detection of the platform at compile time.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setcontext</b><i> (const ucontext_t *<var>ucp</var>)
-</i></td>
+<td align="left"><code>int <b>setcontext</b><i> (const ucontext_t *<var>ucp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>setcontext</code> function restores the context described by
 <var>ucp</var>.  The context is not modified and can be reused as often as
@@ -58056,16 +56769,15 @@
 the one described by the <var>ucp</var> parameter.  This is often useful but
 there are situations where the current context has to be preserved.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>swapcontext</b><i> (ucontext_t *restrict <var>oucp</var>, const ucontext_t *restrict <var>ucp</var>)
-</i></td>
+<td align="left"><code>int <b>swapcontext</b><i> (ucontext_t *restrict <var>oucp</var>, const ucontext_t *restrict <var>ucp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>swapcontext</code> function is similar to <code>setcontext</code> but
 instead of just replacing the current context the latter is first saved
@@ -58242,11 +56954,11 @@
 multiple different scheduling points in the code.  Execution will always
 resume where it was left.
 
 <p><hr>
-Node:<a name="Signal%20Handling">Signal Handling</a>,
-Next:<a rel=next accesskey=n href="#Program%20Basics">Program Basics</a>,
-Previous:<a rel=previous accesskey=p href="#Non-Local%20Exits">Non-Local Exits</a>,
+Node:<a name="Signal Handling">Signal Handling</a>,
+Next:<a rel=next accesskey=n href="#Program Basics">Program Basics</a>,
+Previous:<a rel=previous accesskey=p href="#Non-Local Exits">Non-Local Exits</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Signal Handling</h2>
@@ -58271,29 +56983,29 @@
 parent process to abort a child, or two related processes to communicate
 and synchronize.
 
 <ul>
-<li><a accesskey=1 href="#Concepts%20of%20Signals">Concepts of Signals</a>:          Introduction to the signal facilities. 
-<li><a accesskey=2 href="#Standard%20Signals">Standard Signals</a>:             Particular kinds of signals with
+<li><a accesskey=1 href="#Concepts of Signals">Concepts of Signals</a>:          Introduction to the signal facilities. 
+<li><a accesskey=2 href="#Standard Signals">Standard Signals</a>:             Particular kinds of signals with
                                  standard names and meanings. 
-<li><a accesskey=3 href="#Signal%20Actions">Signal Actions</a>:               Specifying what happens when a
+<li><a accesskey=3 href="#Signal Actions">Signal Actions</a>:               Specifying what happens when a
                                  particular signal is delivered. 
-<li><a accesskey=4 href="#Defining%20Handlers">Defining Handlers</a>:            How to write a signal handler function. 
-<li><a accesskey=5 href="#Interrupted%20Primitives">Interrupted Primitives</a>: 	Signal handlers affect use of <code>open</code>,
+<li><a accesskey=4 href="#Defining Handlers">Defining Handlers</a>:            How to write a signal handler function. 
+<li><a accesskey=5 href="#Interrupted Primitives">Interrupted Primitives</a>: 	Signal handlers affect use of <code>open</code>,
 				 <code>read</code>, <code>write</code> and other functions. 
-<li><a accesskey=6 href="#Generating%20Signals">Generating Signals</a>:           How to send a signal to a process. 
-<li><a accesskey=7 href="#Blocking%20Signals">Blocking Signals</a>:             Making the system hold signals temporarily. 
-<li><a accesskey=8 href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>:         Suspending your program until a signal
+<li><a accesskey=6 href="#Generating Signals">Generating Signals</a>:           How to send a signal to a process. 
+<li><a accesskey=7 href="#Blocking Signals">Blocking Signals</a>:             Making the system hold signals temporarily. 
+<li><a accesskey=8 href="#Waiting for a Signal">Waiting for a Signal</a>:         Suspending your program until a signal
                                  arrives. 
-<li><a accesskey=9 href="#Signal%20Stack">Signal Stack</a>:                 Using a Separate Signal Stack. 
-<li><a href="#BSD%20Signal%20Handling">BSD Signal Handling</a>:          Additional functions for backward
+<li><a accesskey=9 href="#Signal Stack">Signal Stack</a>:                 Using a Separate Signal Stack. 
+<li><a href="#BSD Signal Handling">BSD Signal Handling</a>:          Additional functions for backward
 			         compatibility with BSD. 
 </ul>
 
 <p><hr>
-Node:<a name="Concepts%20of%20Signals">Concepts of Signals</a>,
-Next:<a rel=next accesskey=n href="#Standard%20Signals">Standard Signals</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Concepts of Signals">Concepts of Signals</a>,
+Next:<a rel=next accesskey=n href="#Standard Signals">Standard Signals</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Basic Concepts of Signals</h3>
 
@@ -58301,18 +57013,18 @@
 happens after a signal is delivered, and how programs can handle
 signals.
 
 <ul>
-<li><a accesskey=1 href="#Kinds%20of%20Signals">Kinds of Signals</a>:             Some examples of what can cause a signal. 
-<li><a accesskey=2 href="#Signal%20Generation">Signal Generation</a>:            Concepts of why and how signals occur. 
-<li><a accesskey=3 href="#Delivery%20of%20Signal">Delivery of Signal</a>:           Concepts of what a signal does to the
+<li><a accesskey=1 href="#Kinds of Signals">Kinds of Signals</a>:             Some examples of what can cause a signal. 
+<li><a accesskey=2 href="#Signal Generation">Signal Generation</a>:            Concepts of why and how signals occur. 
+<li><a accesskey=3 href="#Delivery of Signal">Delivery of Signal</a>:           Concepts of what a signal does to the
                                  process. 
 </ul>
 
 <p><hr>
-Node:<a name="Kinds%20of%20Signals">Kinds of Signals</a>,
-Next:<a rel=next accesskey=n href="#Signal%20Generation">Signal Generation</a>,
-Up:<a rel=up accesskey=u href="#Concepts%20of%20Signals">Concepts of Signals</a>
+Node:<a name="Kinds of Signals">Kinds of Signals</a>,
+Next:<a rel=next accesskey=n href="#Signal Generation">Signal Generation</a>,
+Up:<a rel=up accesskey=u href="#Concepts of Signals">Concepts of Signals</a>
 <br>
 
 <h4>Some Kinds of Signals</h4>
 
@@ -58338,22 +57050,22 @@
 <li>A call to <code>kill</code> from another process.  Signals are a limited but
 useful form of interprocess communication.
 
 <li>An attempt to perform an I/O operation that cannot be done.  Examples
-are reading from a pipe that has no writer (see <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>),
-and reading or writing to a terminal in certain situations (see <a href="#Job%20Control">Job Control</a>). 
+are reading from a pipe that has no writer (see <a href="#Pipes and FIFOs">Pipes and FIFOs</a>),
+and reading or writing to a terminal in certain situations (see <a href="#Job Control">Job Control</a>). 
 </ul>
 
 <p>Each of these kinds of events (excepting explicit calls to <code>kill</code>
 and <code>raise</code>) generates its own particular kind of signal.  The
 various kinds of signals are listed and described in detail in
-<a href="#Standard%20Signals">Standard Signals</a>.
+<a href="#Standard Signals">Standard Signals</a>.
 
 <p><hr>
-Node:<a name="Signal%20Generation">Signal Generation</a>,
-Next:<a rel=next accesskey=n href="#Delivery%20of%20Signal">Delivery of Signal</a>,
-Previous:<a rel=previous accesskey=p href="#Kinds%20of%20Signals">Kinds of Signals</a>,
-Up:<a rel=up accesskey=u href="#Concepts%20of%20Signals">Concepts of Signals</a>
+Node:<a name="Signal Generation">Signal Generation</a>,
+Next:<a rel=next accesskey=n href="#Delivery of Signal">Delivery of Signal</a>,
+Previous:<a rel=previous accesskey=p href="#Kinds of Signals">Kinds of Signals</a>,
+Up:<a rel=up accesskey=u href="#Concepts of Signals">Concepts of Signals</a>
 <br>
 
 <h4>Concepts of Signal Generation</h4>
 
@@ -58397,11 +57109,11 @@
 can be generated synchronously or asynchronously with an explicit
 request.
 
 <p><hr>
-Node:<a name="Delivery%20of%20Signal">Delivery of Signal</a>,
-Previous:<a rel=previous accesskey=p href="#Signal%20Generation">Signal Generation</a>,
-Up:<a rel=up accesskey=u href="#Concepts%20of%20Signals">Concepts of Signals</a>
+Node:<a name="Delivery of Signal">Delivery of Signal</a>,
+Previous:<a rel=previous accesskey=p href="#Signal Generation">Signal Generation</a>,
+Up:<a rel=up accesskey=u href="#Concepts of Signals">Concepts of Signals</a>
 <br>
 
 <h4>How Signals Are Delivered</h4>
 
@@ -58409,17 +57121,17 @@
 remains pending for just a short period of time and then is
 <dfn>delivered</dfn> to the process that was signaled.  However, if that kind
 of signal is currently <dfn>blocked</dfn>, it may remain pending
 indefinitely--until signals of that kind are <dfn>unblocked</dfn>.  Once
-unblocked, it will be delivered immediately.  See <a href="#Blocking%20Signals">Blocking Signals</a>.
+unblocked, it will be delivered immediately.  See <a href="#Blocking Signals">Blocking Signals</a>.
 
 <p>When the signal is delivered, whether right away or after a long delay,
 the <dfn>specified action</dfn> for that signal is taken.  For certain
 signals, such as <code>SIGKILL</code> and <code>SIGSTOP</code>, the action is fixed,
 but for most signals, the program has a choice: ignore the signal,
 specify a <dfn>handler function</dfn>, or accept the <dfn>default action</dfn> for
 that kind of signal.  The program specifies its choice using functions
-such as <code>signal</code> or <code>sigaction</code> (see <a href="#Signal%20Actions">Signal Actions</a>).  We
+such as <code>signal</code> or <code>sigaction</code> (see <a href="#Signal Actions">Signal Actions</a>).  We
 sometimes say that a handler <dfn>catches</dfn> the signal.  While the
 handler is running, that particular signal is normally blocked.
 
 <p>If the specified action for a kind of signal is to ignore it, then any
@@ -58430,17 +57142,17 @@
 it.
 
 <p>If a signal arrives which the program has neither handled nor ignored,
 its <dfn>default action</dfn> takes place.  Each kind of signal has its own
-default action, documented below (see <a href="#Standard%20Signals">Standard Signals</a>).  For most kinds
+default action, documented below (see <a href="#Standard Signals">Standard Signals</a>).  For most kinds
 of signals, the default action is to terminate the process.  For certain
 kinds of signals that represent "harmless" events, the default action
 is to do nothing.
 
 <p>When a signal terminates a process, its parent process can determine the
 cause of termination by examining the termination status code reported
 by the <code>wait</code> or <code>waitpid</code> functions.  (This is discussed in
-more detail in <a href="#Process%20Completion">Process Completion</a>.)  The information it can get
+more detail in <a href="#Process Completion">Process Completion</a>.)  The information it can get
 includes the fact that termination was due to a signal and the kind of
 signal involved.  If a program you run from a shell is terminated by a
 signal, the shell typically prints some kind of error message.
 
@@ -58454,12 +57166,12 @@
 terminates the process, it makes a core dump file just as if the signal
 had been due directly to an error.
 
 <p><hr>
-Node:<a name="Standard%20Signals">Standard Signals</a>,
-Next:<a rel=next accesskey=n href="#Signal%20Actions">Signal Actions</a>,
-Previous:<a rel=previous accesskey=p href="#Concepts%20of%20Signals">Concepts of Signals</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Standard Signals">Standard Signals</a>,
+Next:<a rel=next accesskey=n href="#Signal Actions">Signal Actions</a>,
+Previous:<a rel=previous accesskey=p href="#Concepts of Signals">Concepts of Signals</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Standard Signals</h3>
 
@@ -58474,39 +57186,38 @@
 
 <p>The signal names are defined in the header file <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>NSIG</b><i>
-</i></td>
+<td align="left"><code>int <b>NSIG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this symbolic constant is the total number of signals
 defined.  Since the signal numbers are allocated consecutively,
 <code>NSIG</code> is also one greater than the largest defined signal number. 
 </td></tr>
 </table>
 
 <ul>
-<li><a accesskey=1 href="#Program%20Error%20Signals">Program Error Signals</a>:        Used to report serious program errors. 
-<li><a accesskey=2 href="#Termination%20Signals">Termination Signals</a>:          Used to interrupt and/or terminate the
+<li><a accesskey=1 href="#Program Error Signals">Program Error Signals</a>:        Used to report serious program errors. 
+<li><a accesskey=2 href="#Termination Signals">Termination Signals</a>:          Used to interrupt and/or terminate the
                                  program. 
-<li><a accesskey=3 href="#Alarm%20Signals">Alarm Signals</a>:                Used to indicate expiration of timers. 
-<li><a accesskey=4 href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>:     Used to indicate input is available. 
-<li><a accesskey=5 href="#Job%20Control%20Signals">Job Control Signals</a>:          Signals used to support job control. 
-<li><a accesskey=6 href="#Operation%20Error%20Signals">Operation Error Signals</a>:      Used to report operational system errors. 
-<li><a accesskey=7 href="#Miscellaneous%20Signals">Miscellaneous Signals</a>:        Miscellaneous Signals. 
-<li><a accesskey=8 href="#Signal%20Messages">Signal Messages</a>:              Printing a message describing a signal. 
+<li><a accesskey=3 href="#Alarm Signals">Alarm Signals</a>:                Used to indicate expiration of timers. 
+<li><a accesskey=4 href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>:     Used to indicate input is available. 
+<li><a accesskey=5 href="#Job Control Signals">Job Control Signals</a>:          Signals used to support job control. 
+<li><a accesskey=6 href="#Operation Error Signals">Operation Error Signals</a>:      Used to report operational system errors. 
+<li><a accesskey=7 href="#Miscellaneous Signals">Miscellaneous Signals</a>:        Miscellaneous Signals. 
+<li><a accesskey=8 href="#Signal Messages">Signal Messages</a>:              Printing a message describing a signal. 
 </ul>
 
 <p><hr>
-Node:<a name="Program%20Error%20Signals">Program Error Signals</a>,
-Next:<a rel=next accesskey=n href="#Termination%20Signals">Termination Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Program Error Signals">Program Error Signals</a>,
+Next:<a rel=next accesskey=n href="#Termination Signals">Termination Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Program Error Signals</h4>
 
@@ -58521,9 +57232,9 @@
 input should handle program error signals in order to turn echoing back
 on.  The handler should end by specifying the default action for the
 signal that happened and then reraising it; this will cause the program
 to terminate with that signal, as if it had not had a handler. 
-(See <a href="#Termination%20in%20Handler">Termination in Handler</a>.)
+(See <a href="#Termination in Handler">Termination in Handler</a>.)
 
 <p>Termination is the sensible ultimate outcome from a program error in
 most programs.  However, programming systems such as Lisp that can load
 compiled user programs might need to keep executing even if a user
@@ -58545,16 +57256,15 @@
 files is so that you can examine them with a debugger to investigate
 what caused the error.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGFPE</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGFPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGFPE</code> signal reports a fatal arithmetic error.  Although the
 name is derived from "floating-point exception", this signal actually
 covers all arithmetic errors, including division by zero and overflow. 
@@ -58603,16 +57313,15 @@
 C never uses it.) 
 </dl>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGILL</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGILL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The name of this signal is derived from "illegal instruction"; it
 usually means your program is trying to execute garbage or a privileged
 instruction.  Since the C compiler generates only valid instructions,
@@ -58629,16 +57338,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGSEGV</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGSEGV</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal is generated when a program tries to read or write outside
 the memory that is allocated for it, or to write memory that can only be
 read.  (Actually, the signals only occur when the program goes far
@@ -58653,16 +57361,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGBUS</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGBUS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal is generated when an invalid pointer is dereferenced.  Like
 <code>SIGSEGV</code>, this signal is typically the result of dereferencing an
 uninitialized pointer.  The difference between the two is that
@@ -58677,46 +57384,43 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGABRT</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGABRT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal indicates an error detected by the program itself and
-reported by calling <code>abort</code>.  See <a href="#Aborting%20a%20Program">Aborting a Program</a>. 
+reported by calling <code>abort</code>.  See <a href="#Aborting a Program">Aborting a Program</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGIOT</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGIOT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Generated by the PDP-11 "iot" instruction.  On most machines, this is
 just another name for <code>SIGABRT</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGTRAP</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGTRAP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Generated by the machine's breakpoint instruction, and possibly other
 trap instructions.  This signal is used by debuggers.  Your program will
 probably only see <code>SIGTRAP</code> if it is somehow executing bad
@@ -58724,44 +57428,42 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGEMT</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGEMT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Emulator trap; this results from certain unimplemented instructions
 which might be emulated in software, or the operating system's
 failure to properly emulate them. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGSYS</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGSYS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Bad system call; that is to say, the instruction to trap to the
 operating system was executed, but the code number for the system call
 to perform was invalid. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Termination%20Signals">Termination Signals</a>,
-Next:<a rel=next accesskey=n href="#Alarm%20Signals">Alarm Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Program%20Error%20Signals">Program Error Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Termination Signals">Termination Signals</a>,
+Next:<a rel=next accesskey=n href="#Alarm Signals">Alarm Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Program Error Signals">Program Error Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Termination Signals</h4>
 
@@ -58774,22 +57476,21 @@
 might want to save state information, delete temporary files, or restore
 the previous terminal modes.  Such a handler should end by specifying
 the default action for the signal that happened and then reraising it;
 this will cause the program to terminate with that signal, as if it had
-not had a handler.  (See <a href="#Termination%20in%20Handler">Termination in Handler</a>.)
+not had a handler.  (See <a href="#Termination in Handler">Termination in Handler</a>.)
 
 <p>The (obvious) default action for all of these signals is to cause the
 process to terminate.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGTERM</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGTERM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGTERM</code> signal is a generic signal used to cause program
 termination.  Unlike <code>SIGKILL</code>, this signal can be blocked,
 handled, and ignored.  It is the normal way to politely ask a program to
@@ -58799,41 +57500,39 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGINT</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGINT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGINT</code> ("program interrupt") signal is sent when the user
-types the INTR character (normally <kbd>C-c</kbd>).  See <a href="#Special%20Characters">Special Characters</a>, for information about terminal driver support for
+types the INTR character (normally <kbd>C-c</kbd>).  See <a href="#Special Characters">Special Characters</a>, for information about terminal driver support for
 <kbd>C-c</kbd>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGQUIT</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGQUIT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGQUIT</code> signal is similar to <code>SIGINT</code>, except that it's
 controlled by a different key--the QUIT character, usually
 <kbd>C-\</kbd>--and produces a core dump when it terminates the process,
 just like a program error signal.  You can think of this as a
 program error condition "detected" by the user.
 
-<p>See <a href="#Program%20Error%20Signals">Program Error Signals</a>, for information about core dumps. 
-See <a href="#Special%20Characters">Special Characters</a>, for information about terminal driver
+<p>See <a href="#Program Error Signals">Program Error Signals</a>, for information about core dumps. 
+See <a href="#Special Characters">Special Characters</a>, for information about terminal driver
 support.
 
 <p>Certain kinds of cleanups are best omitted in handling <code>SIGQUIT</code>. 
 For example, if the program creates temporary files, it should handle
@@ -58843,16 +57542,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGKILL</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGKILL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGKILL</code> signal is used to cause immediate program termination. 
 It cannot be handled or ignored, and is therefore always fatal.  It is
 also not possible to block this signal.
@@ -58872,86 +57570,82 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGHUP</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGHUP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGHUP</code> ("hang-up") signal is used to report that the user's
 terminal is disconnected, perhaps because a network or telephone
-connection was broken.  For more information about this, see <a href="#Control%20Modes">Control Modes</a>.
+connection was broken.  For more information about this, see <a href="#Control Modes">Control Modes</a>.
 
 <p>This signal is also used to report the termination of the controlling
 process on a terminal to jobs associated with that session; this
 termination effectively disconnects all processes in the session from
-the controlling terminal.  For more information, see <a href="#Termination%20Internals">Termination Internals</a>. 
+the controlling terminal.  For more information, see <a href="#Termination Internals">Termination Internals</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Alarm%20Signals">Alarm Signals</a>,
-Next:<a rel=next accesskey=n href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Termination%20Signals">Termination Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Alarm Signals">Alarm Signals</a>,
+Next:<a rel=next accesskey=n href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Termination Signals">Termination Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Alarm Signals</h4>
 
 <p>These signals are used to indicate the expiration of timers. 
-See <a href="#Setting%20an%20Alarm">Setting an Alarm</a>, for information about functions that cause
+See <a href="#Setting an Alarm">Setting an Alarm</a>, for information about functions that cause
 these signals to be sent.
 
 <p>The default behavior for these signals is to cause program termination. 
 This default is rarely useful, but no other default would be useful;
 most of the ways of using these signals would require handler functions
 in any case.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGALRM</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGALRM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal typically indicates expiration of a timer that measures real
 or clock time.  It is used by the <code>alarm</code> function, for example. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGVTALRM</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGVTALRM</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal typically indicates expiration of a timer that measures CPU
 time used by the current process.  The name is an abbreviation for
 "virtual time alarm". 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGPROF</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGPROF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal typically indicates expiration of a timer that measures
 both CPU time used by the current process, and CPU time expended on
 behalf of the process by the system.  Such a timer is used to implement
@@ -58959,31 +57653,30 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>,
-Next:<a rel=next accesskey=n href="#Job%20Control%20Signals">Job Control Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Alarm%20Signals">Alarm Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>,
+Next:<a rel=next accesskey=n href="#Job Control Signals">Job Control Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Alarm Signals">Alarm Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Asynchronous I/O Signals</h4>
 
 <p>The signals listed in this section are used in conjunction with
 asynchronous I/O facilities.  You have to take explicit action by
 calling <code>fcntl</code> to enable a particular file descriptor to generate
-these signals (see <a href="#Interrupt%20Input">Interrupt Input</a>).  The default action for these
+these signals (see <a href="#Interrupt Input">Interrupt Input</a>).  The default action for these
 signals is to ignore them.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGIO</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGIO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal is sent when a file descriptor is ready to perform input
 or output.
 
@@ -58996,42 +57689,40 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGURG</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGURG</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal is sent when "urgent" or out-of-band data arrives on a
-socket.  See <a href="#Out-of-Band%20Data">Out-of-Band Data</a>. 
+socket.  See <a href="#Out-of-Band Data">Out-of-Band Data</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGPOLL</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGPOLL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a System V signal name, more or less similar to <code>SIGIO</code>. 
 It is defined only for compatibility. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Job%20Control%20Signals">Job Control Signals</a>,
-Next:<a rel=next accesskey=n href="#Operation%20Error%20Signals">Operation Error Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Job Control Signals">Job Control Signals</a>,
+Next:<a rel=next accesskey=n href="#Operation Error Signals">Operation Error Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Job Control Signals</h4>
 
@@ -59039,55 +57730,52 @@
 doesn't support job control, then these macros are defined but the
 signals themselves can't be raised or handled.
 
 <p>You should generally leave these signals alone unless you really
-understand how job control works.  See <a href="#Job%20Control">Job Control</a>.
+understand how job control works.  See <a href="#Job Control">Job Control</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGCHLD</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGCHLD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This signal is sent to a parent process whenever one of its child
 processes terminates or stops.
 
 <p>The default action for this signal is to ignore it.  If you establish a
 handler for this signal while there are child processes that have
 terminated but not reported their status via <code>wait</code> or
-<code>waitpid</code> (see <a href="#Process%20Completion">Process Completion</a>), whether your new handler
+<code>waitpid</code> (see <a href="#Process Completion">Process Completion</a>), whether your new handler
 applies to those processes or not depends on the particular operating
 system. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGCLD</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGCLD</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an obsolete name for <code>SIGCHLD</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGCONT</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGCONT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 You can send a <code>SIGCONT</code> signal to a process to make it continue. 
 This signal is special--it always makes the process continue if it is
 stopped, before the signal is delivered.  The default behavior is to do
@@ -59102,31 +57790,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGSTOP</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGSTOP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGSTOP</code> signal stops the process.  It cannot be handled,
 ignored, or blocked. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGTSTP</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGTSTP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGTSTP</code> signal is an interactive stop signal.  Unlike
 <code>SIGSTOP</code>, this signal can be handled and ignored.
 
@@ -59136,46 +57822,44 @@
 <code>SIGTSTP</code> so they can turn echoing back on before stopping.
 
 <p>This signal is generated when the user types the SUSP character
 (normally <kbd>C-z</kbd>).  For more information about terminal driver
-support, see <a href="#Special%20Characters">Special Characters</a>. 
+support, see <a href="#Special Characters">Special Characters</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGTTIN</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGTTIN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A process cannot read from the user's terminal while it is running
 as a background job.  When any process in a background job tries to
 read from the terminal, all of the processes in the job are sent a
 <code>SIGTTIN</code> signal.  The default action for this signal is to
 stop the process.  For more information about how this interacts with
-the terminal driver, see <a href="#Access%20to%20the%20Terminal">Access to the Terminal</a>. 
+the terminal driver, see <a href="#Access to the Terminal">Access to the Terminal</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGTTOU</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGTTOU</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>SIGTTIN</code>, but is generated when a process in a
 background job attempts to write to the terminal or set its modes. 
 Again, the default action is to stop the process.  <code>SIGTTOU</code> is
 only generated for an attempt to write to the terminal if the
-<code>TOSTOP</code> output mode is set; see <a href="#Output%20Modes">Output Modes</a>. 
+<code>TOSTOP</code> output mode is set; see <a href="#Output Modes">Output Modes</a>. 
 </td></tr>
 </table>
 
 <p>While a process is stopped, no more signals can be delivered to it until
@@ -59188,9 +57872,9 @@
 <code>SIGCONT</code> signal to a process causes any pending stop signals for
 that process to be discarded.  Likewise, any pending <code>SIGCONT</code>
 signals for a process are discarded when it receives a stop signal.
 
-<p>When a process in an orphaned process group (see <a href="#Orphaned%20Process%20Groups">Orphaned Process Groups</a>) receives a <code>SIGTSTP</code>, <code>SIGTTIN</code>, or <code>SIGTTOU</code>
+<p>When a process in an orphaned process group (see <a href="#Orphaned Process Groups">Orphaned Process Groups</a>) receives a <code>SIGTSTP</code>, <code>SIGTTIN</code>, or <code>SIGTTOU</code>
 signal and does not handle it, the process does not stop.  Stopping the
 process would probably not be very useful, since there is no shell
 program that will notice it stop and allow the user to continue it. 
 What happens instead depends on the operating system you are using. 
@@ -59199,12 +57883,12 @@
 dies with <code>SIGKILL</code>; this avoids the problem of many stopped,
 orphaned processes lying around the system.
 
 <p><hr>
-Node:<a name="Operation%20Error%20Signals">Operation Error Signals</a>,
-Next:<a rel=next accesskey=n href="#Miscellaneous%20Signals">Miscellaneous Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Job%20Control%20Signals">Job Control Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Operation Error Signals">Operation Error Signals</a>,
+Next:<a rel=next accesskey=n href="#Miscellaneous Signals">Miscellaneous Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Job Control Signals">Job Control Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Operation Error Signals</h4>
 
@@ -59214,40 +57898,38 @@
 operating system call from completing.  The default action for all of
 them is to cause the process to terminate.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGPIPE</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGPIPE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Broken pipe.  If you use pipes or FIFOs, you have to design your
 application so that one process opens the pipe for reading before
 another starts writing.  If the reading process never starts, or
 terminates unexpectedly, writing to the pipe or FIFO raises a
 <code>SIGPIPE</code> signal.  If <code>SIGPIPE</code> is blocked, handled or
 ignored, the offending call fails with <code>EPIPE</code> instead.
 
-<p>Pipes and FIFO special files are discussed in more detail in <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>.
+<p>Pipes and FIFO special files are discussed in more detail in <a href="#Pipes and FIFOs">Pipes and FIFOs</a>.
 
 <p>Another cause of <code>SIGPIPE</code> is when you try to output to a socket
-that isn't connected.  See <a href="#Sending%20Data">Sending Data</a>. 
+that isn't connected.  See <a href="#Sending Data">Sending Data</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGLOST</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGLOST</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Resource lost.  This signal is generated when you have an advisory lock
 on an NFS file, and the NFS server reboots and forgets about your lock.
 
@@ -59257,90 +57939,85 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGXCPU</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGXCPU</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 CPU time limit exceeded.  This signal is generated when the process
-exceeds its soft resource limit on CPU time.  See <a href="#Limits%20on%20Resources">Limits on Resources</a>. 
+exceeds its soft resource limit on CPU time.  See <a href="#Limits on Resources">Limits on Resources</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGXFSZ</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGXFSZ</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 File size limit exceeded.  This signal is generated when the process
 attempts to extend a file so it exceeds the process's soft resource
-limit on file size.  See <a href="#Limits%20on%20Resources">Limits on Resources</a>. 
+limit on file size.  See <a href="#Limits on Resources">Limits on Resources</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Miscellaneous%20Signals">Miscellaneous Signals</a>,
-Next:<a rel=next accesskey=n href="#Signal%20Messages">Signal Messages</a>,
-Previous:<a rel=previous accesskey=p href="#Operation%20Error%20Signals">Operation Error Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Miscellaneous Signals">Miscellaneous Signals</a>,
+Next:<a rel=next accesskey=n href="#Signal Messages">Signal Messages</a>,
+Previous:<a rel=previous accesskey=p href="#Operation Error Signals">Operation Error Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Miscellaneous Signals</h4>
 
 <p>These signals are used for various other purposes.  In general, they
 will not affect your program unless it explicitly uses them for something.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGUSR1</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGUSR1</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">int <b>SIGUSR2</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGUSR2</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>SIGUSR1</code> and <code>SIGUSR2</code> signals are set aside for you to
 use any way you want.  They're useful for simple interprocess
 communication, if you write a signal handler for them in the program
 that receives the signal.
 
 <p>There is an example showing the use of <code>SIGUSR1</code> and <code>SIGUSR2</code>
-in <a href="#Signaling%20Another%20Process">Signaling Another Process</a>.
+in <a href="#Signaling Another Process">Signaling Another Process</a>.
 
 <p>The default action is to terminate the process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGWINCH</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGWINCH</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Window size change.  This is generated on some systems (including GNU)
 when the terminal driver's record of the number of rows and columns on
 the screen is changed.  The default action is to ignore it.
@@ -59351,32 +58028,31 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SIGINFO</b><i>
-</i></td>
+<td align="left"><code>int <b>SIGINFO</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Information request.  In 4.4 BSD and the GNU system, this signal is sent
 to all the processes in the foreground process group of the controlling
 terminal when the user types the STATUS character in canonical mode;
-see <a href="#Signal%20Characters">Signal Characters</a>.
+see <a href="#Signal Characters">Signal Characters</a>.
 
 <p>If the process is the leader of the process group, the default action is
 to print some status information about the system and what the process
 is doing.  Otherwise the default is to do nothing. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Signal%20Messages">Signal Messages</a>,
-Previous:<a rel=previous accesskey=p href="#Miscellaneous%20Signals">Miscellaneous Signals</a>,
-Up:<a rel=up accesskey=u href="#Standard%20Signals">Standard Signals</a>
+Node:<a name="Signal Messages">Signal Messages</a>,
+Previous:<a rel=previous accesskey=p href="#Miscellaneous Signals">Miscellaneous Signals</a>,
+Up:<a rel=up accesskey=u href="#Standard Signals">Standard Signals</a>
 <br>
 
 <h4>Signal Messages</h4>
 
@@ -59384,20 +58060,19 @@
 that terminated a child process.  The clean way to print a message
 describing a signal is to use the functions <code>strsignal</code> and
 <code>psignal</code>.  These functions use a signal number to specify which
 kind of signal to describe.  The signal number may come from the
-termination status of a child process (see <a href="#Process%20Completion">Process Completion</a>) or it
+termination status of a child process (see <a href="#Process Completion">Process Completion</a>) or it
 may come from a signal handler in the same process.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>strsignal</b><i> (int <var>signum</var>)
-</i></td>
+<td align="left"><code>char * <b>strsignal</b><i> (int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a pointer to a statically-allocated string
 containing a message describing the signal <var>signum</var>.  You
 should not modify the contents of this string; and, since it can be
@@ -59409,19 +58084,18 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>psignal</b><i> (int <var>signum</var>, const char *<var>message</var>)
-</i></td>
+<td align="left"><code>void <b>psignal</b><i> (int <var>signum</var>, const char *<var>message</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function prints a message describing the signal <var>signum</var> to the
-standard error output stream <code>stderr</code>; see <a href="#Standard%20Streams">Standard Streams</a>.
+standard error output stream <code>stderr</code>; see <a href="#Standard Streams">Standard Streams</a>.
 
 <p>If you call <code>psignal</code> with a <var>message</var> that is either a null
 pointer or an empty string, <code>psignal</code> just prints the message
 corresponding to <var>signum</var>, adding a trailing newline.
@@ -59439,12 +58113,12 @@
 for the various signal codes.  This array exists on BSD systems, unlike
 <code>strsignal</code>.
 
 <p><hr>
-Node:<a name="Signal%20Actions">Signal Actions</a>,
-Next:<a rel=next accesskey=n href="#Defining%20Handlers">Defining Handlers</a>,
-Previous:<a rel=previous accesskey=p href="#Standard%20Signals">Standard Signals</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Signal Actions">Signal Actions</a>,
+Next:<a rel=next accesskey=n href="#Defining Handlers">Defining Handlers</a>,
+Previous:<a rel=previous accesskey=p href="#Standard Signals">Standard Signals</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Specifying Signal Actions</h3>
 
@@ -59456,20 +58130,20 @@
 facility.  This section describes both facilities and gives suggestions
 on which to use when.
 
 <ul>
-<li><a accesskey=1 href="#Basic%20Signal%20Handling">Basic Signal Handling</a>:        The simple <code>signal</code> function. 
-<li><a accesskey=2 href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>:     The more powerful <code>sigaction</code> function. 
-<li><a accesskey=3 href="#Signal%20and%20Sigaction">Signal and Sigaction</a>:         How those two functions interact. 
-<li><a accesskey=4 href="#Sigaction%20Function%20Example">Sigaction Function Example</a>:   An example of using the sigaction function. 
-<li><a accesskey=5 href="#Flags%20for%20Sigaction">Flags for Sigaction</a>:          Specifying options for signal handling. 
-<li><a accesskey=6 href="#Initial%20Signal%20Actions">Initial Signal Actions</a>:       How programs inherit signal actions. 
+<li><a accesskey=1 href="#Basic Signal Handling">Basic Signal Handling</a>:        The simple <code>signal</code> function. 
+<li><a accesskey=2 href="#Advanced Signal Handling">Advanced Signal Handling</a>:     The more powerful <code>sigaction</code> function. 
+<li><a accesskey=3 href="#Signal and Sigaction">Signal and Sigaction</a>:         How those two functions interact. 
+<li><a accesskey=4 href="#Sigaction Function Example">Sigaction Function Example</a>:   An example of using the sigaction function. 
+<li><a accesskey=5 href="#Flags for Sigaction">Flags for Sigaction</a>:          Specifying options for signal handling. 
+<li><a accesskey=6 href="#Initial Signal Actions">Initial Signal Actions</a>:       How programs inherit signal actions. 
 </ul>
 
 <p><hr>
-Node:<a name="Basic%20Signal%20Handling">Basic Signal Handling</a>,
-Next:<a rel=next accesskey=n href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Actions">Signal Actions</a>
+Node:<a name="Basic Signal Handling">Basic Signal Handling</a>,
+Next:<a rel=next accesskey=n href="#Advanced Signal Handling">Advanced Signal Handling</a>,
+Up:<a rel=up accesskey=u href="#Signal Actions">Signal Actions</a>
 <br>
 
 <h4>Basic Signal Handling</h4>
 
@@ -59477,16 +58151,15 @@
 an action for a particular signal.  The function and associated macros
 are declared in the header file <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>sighandler_t</b><i>
-</i></td>
+<td align="left"><code><b>sighandler_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the type of signal handler functions.  Signal handlers take one
 integer argument specifying the signal number, and have return type
 <code>void</code>.  So, you should define handler functions like this:
@@ -59498,24 +58171,23 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">sighandler_t <b>signal</b><i> (int <var>signum</var>, sighandler_t <var>action</var>)
-</i></td>
+<td align="left"><code>sighandler_t <b>signal</b><i> (int <var>signum</var>, sighandler_t <var>action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>signal</code> function establishes <var>action</var> as the action for
 the signal <var>signum</var>.
 
 <p>The first argument, <var>signum</var>, identifies the signal whose behavior
 you want to control, and should be a signal number.  The proper way to
 specify a signal number is with one of the symbolic signal names
-(see <a href="#Standard%20Signals">Standard Signals</a>)--don't use an explicit number, because
+(see <a href="#Standard Signals">Standard Signals</a>)--don't use an explicit number, because
 the numerical code for a given kind of signal may vary from operating
 system to operating system.
 
 <p>The second argument, <var>action</var>, specifies the action to use for the
@@ -59524,9 +58196,9 @@
 <dl>
 <dt><code>SIG_DFL</code>
 <dd><code>SIG_DFL</code> specifies the default action for the particular signal. 
 The default actions for various kinds of signals are stated in
-<a href="#Standard%20Signals">Standard Signals</a>.
+<a href="#Standard Signals">Standard Signals</a>.
 
 <br><dt><code>SIG_IGN</code>
 <dd><code>SIG_IGN</code> specifies that the signal should be ignored.
 
@@ -59539,16 +58211,16 @@
 is unfriendly.
 
 <p>When you do not wish signals to be delivered during a certain part of
 the program, the thing to do is to block them, not ignore them. 
-See <a href="#Blocking%20Signals">Blocking Signals</a>.
+See <a href="#Blocking Signals">Blocking Signals</a>.
 
 <br><dt><code><var>handler</var></code>
 <dd>Supply the address of a handler function in your program, to specify
 running this handler as the way to deliver the signal.
 
 <p>For more information about defining signal handler functions,
-see <a href="#Defining%20Handlers">Defining Handlers</a>. 
+see <a href="#Defining Handlers">Defining Handlers</a>. 
 </dl>
 
 <p>If you set the action for a signal to <code>SIG_IGN</code>, or if you set it
 to <code>SIG_DFL</code> and the default action is to ignore that signal, then
@@ -59579,9 +58251,9 @@
 is deinstalled after signal delivery.  On BSD systems the
 handler must be explicitly deinstalled.  In the GNU C Library we use the
 BSD version by default.  To use the SVID version you can either use the
 function <code>sysv_signal</code> (see below) or use the <code>_XOPEN_SOURCE</code>
-feature select macro (see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>).  In general, use of these
+feature select macro (see <a href="#Feature Test Macros">Feature Test Macros</a>).  In general, use of these
 functions should be avoided because of compatibility problems.  It
 is better to use <code>sigaction</code> if it is available since the results
 are much more reliable.
 
@@ -59622,16 +58294,15 @@
 example because these are designed to provide information for debugging
 (a core dump), and the temporary files may give useful information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">sighandler_t <b>sysv_signal</b><i> (int <var>signum</var>, sighandler_t <var>action</var>)
-</i></td>
+<td align="left"><code>sighandler_t <b>sysv_signal</b><i> (int <var>signum</var>, sighandler_t <var>action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sysv_signal</code> implements the behavior of the standard
 <code>signal</code> function as found on SVID systems.  The difference to BSD
 systems is that the handler is deinstalled after a delivery of a signal.
@@ -59642,42 +58313,40 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">sighandler_t <b>ssignal</b><i> (int <var>signum</var>, sighandler_t <var>action</var>)
-</i></td>
+<td align="left"><code>sighandler_t <b>ssignal</b><i> (int <var>signum</var>, sighandler_t <var>action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ssignal</code> function does the same thing as <code>signal</code>; it is
 provided only for compatibility with SVID. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">sighandler_t <b>SIG_ERR</b><i>
-</i></td>
+<td align="left"><code>sighandler_t <b>SIG_ERR</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is used as the return value from <code>signal</code>
 to indicate an error. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Advanced%20Signal%20Handling">Advanced Signal Handling</a>,
-Next:<a rel=next accesskey=n href="#Signal%20and%20Sigaction">Signal and Sigaction</a>,
-Previous:<a rel=previous accesskey=p href="#Basic%20Signal%20Handling">Basic Signal Handling</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Actions">Signal Actions</a>
+Node:<a name="Advanced Signal Handling">Advanced Signal Handling</a>,
+Next:<a rel=next accesskey=n href="#Signal and Sigaction">Signal and Sigaction</a>,
+Previous:<a rel=previous accesskey=p href="#Basic Signal Handling">Basic Signal Handling</a>,
+Up:<a rel=up accesskey=u href="#Signal Actions">Signal Actions</a>
 <br>
 
 <h4>Advanced Signal Handling</h4>
 
@@ -59690,16 +58359,15 @@
 
 <p>The <code>sigaction</code> function is declared in <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sigaction</b><i>
-</i></td>
+<td align="left"><code><b>struct sigaction</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Structures of type <code>struct sigaction</code> are used in the
 <code>sigaction</code> function to specify all the information about how to
 handle a particular signal.  This structure contains at least the
@@ -59708,34 +58376,33 @@
 <dl>
 <dt><code>sighandler_t sa_handler</code>
 <dd>This is used in the same way as the <var>action</var> argument to the
 <code>signal</code> function.  The value can be <code>SIG_DFL</code>,
-<code>SIG_IGN</code>, or a function pointer.  See <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>.
+<code>SIG_IGN</code>, or a function pointer.  See <a href="#Basic Signal Handling">Basic Signal Handling</a>.
 
 <br><dt><code>sigset_t sa_mask</code>
 <dd>This specifies a set of signals to be blocked while the handler runs. 
-Blocking is explained in <a href="#Blocking%20for%20Handler">Blocking for Handler</a>.  Note that the
+Blocking is explained in <a href="#Blocking for Handler">Blocking for Handler</a>.  Note that the
 signal that was delivered is automatically blocked by default before its
 handler is started; this is true regardless of the value in
 <code>sa_mask</code>.  If you want that signal not to be blocked within its
 handler, you must write code in the handler to unblock it.
 
 <br><dt><code>int sa_flags</code>
 <dd>This specifies various flags which can affect the behavior of
-the signal.  These are described in more detail in <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>. 
+the signal.  These are described in more detail in <a href="#Flags for Sigaction">Flags for Sigaction</a>. 
 </dl>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigaction</b><i> (int <var>signum</var>, const struct sigaction *restrict <var>action</var>, struct sigaction *restrict <var>old-action</var>)
-</i></td>
+<td align="left"><code>int <b>sigaction</b><i> (int <var>signum</var>, const struct sigaction *restrict <var>action</var>, struct sigaction *restrict <var>old-action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <var>action</var> argument is used to set up a new action for the signal
 <var>signum</var>, while the <var>old-action</var> argument is used to return
 information about the action previously associated with this symbol. 
@@ -59763,12 +58430,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Signal%20and%20Sigaction">Signal and Sigaction</a>,
-Next:<a rel=next accesskey=n href="#Sigaction%20Function%20Example">Sigaction Function Example</a>,
-Previous:<a rel=previous accesskey=p href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Actions">Signal Actions</a>
+Node:<a name="Signal and Sigaction">Signal and Sigaction</a>,
+Next:<a rel=next accesskey=n href="#Sigaction Function Example">Sigaction Function Example</a>,
+Previous:<a rel=previous accesskey=p href="#Advanced Signal Handling">Advanced Signal Handling</a>,
+Up:<a rel=up accesskey=u href="#Signal Actions">Signal Actions</a>
 <br>
 
 <h4>Interaction of <code>signal</code> and <code>sigaction</code></h4>
 
@@ -59804,17 +58471,17 @@
 you are concerned about portability to non-POSIX systems, then you
 should use the <code>signal</code> function instead.
 
 <p><hr>
-Node:<a name="Sigaction%20Function%20Example">Sigaction Function Example</a>,
-Next:<a rel=next accesskey=n href="#Flags%20for%20Sigaction">Flags for Sigaction</a>,
-Previous:<a rel=previous accesskey=p href="#Signal%20and%20Sigaction">Signal and Sigaction</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Actions">Signal Actions</a>
+Node:<a name="Sigaction Function Example">Sigaction Function Example</a>,
+Next:<a rel=next accesskey=n href="#Flags for Sigaction">Flags for Sigaction</a>,
+Previous:<a rel=previous accesskey=p href="#Signal and Sigaction">Signal and Sigaction</a>,
+Up:<a rel=up accesskey=u href="#Signal Actions">Signal Actions</a>
 <br>
 
 <h4><code>sigaction</code> Function Example</h4>
 
-<p>In <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>, we gave an example of establishing a
+<p>In <a href="#Basic Signal Handling">Basic Signal Handling</a>, we gave an example of establishing a
 simple handler for termination signals using <code>signal</code>.  Here is an
 equivalent example using <code>sigaction</code>:
 
 <br><pre>#include &lt;signal.h&gt;
@@ -59853,9 +58520,9 @@
 </pre>
 
 <p>The program just loads the <code>new_action</code> structure with the desired
 parameters and passes it in the <code>sigaction</code> call.  The usage of
-<code>sigemptyset</code> is described later; see <a href="#Blocking%20Signals">Blocking Signals</a>.
+<code>sigemptyset</code> is described later; see <a href="#Blocking Signals">Blocking Signals</a>.
 
 <p>As in the example using <code>signal</code>, we avoid handling signals
 previously set to be ignored.  Here we can avoid altering the signal
 handler even momentarily, by using the feature of <code>sigaction</code> that
@@ -59876,12 +58543,12 @@
   /* A programmer-defined signal handler is in effect. */
 </pre>
 
 <p><hr>
-Node:<a name="Flags%20for%20Sigaction">Flags for Sigaction</a>,
-Next:<a rel=next accesskey=n href="#Initial%20Signal%20Actions">Initial Signal Actions</a>,
-Previous:<a rel=previous accesskey=p href="#Sigaction%20Function%20Example">Sigaction Function Example</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Actions">Signal Actions</a>
+Node:<a name="Flags for Sigaction">Flags for Sigaction</a>,
+Next:<a rel=next accesskey=n href="#Initial Signal Actions">Initial Signal Actions</a>,
+Previous:<a rel=previous accesskey=p href="#Sigaction Function Example">Sigaction Function Example</a>,
+Up:<a rel=up accesskey=u href="#Signal Actions">Signal Actions</a>
 <br>
 
 <h4>Flags for <code>sigaction</code></h4>
 
@@ -59899,21 +58566,20 @@
 that you specify apply only to that particular signal.
 
 <p>In the GNU C library, establishing a handler with <code>signal</code> sets all
 the flags to zero except for <code>SA_RESTART</code>, whose value depends on
-the settings you have made with <code>siginterrupt</code>.  See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>, to see what this is about.
+the settings you have made with <code>siginterrupt</code>.  See <a href="#Interrupted Primitives">Interrupted Primitives</a>, to see what this is about.
 
 <p>These macros are defined in the header file <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SA_NOCLDSTOP</b><i>
-</i></td>
+<td align="left"><code>int <b>SA_NOCLDSTOP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This flag is meaningful only for the <code>SIGCHLD</code> signal.  When the
 flag is set, the system delivers the signal for a terminated child
 process but not for one that is stopped.  By default, <code>SIGCHLD</code> is
@@ -59923,33 +58589,31 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SA_ONSTACK</b><i>
-</i></td>
+<td align="left"><code>int <b>SA_ONSTACK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this flag is set for a particular signal number, the system uses the
-signal stack when delivering that kind of signal.  See <a href="#Signal%20Stack">Signal Stack</a>. 
+signal stack when delivering that kind of signal.  See <a href="#Signal Stack">Signal Stack</a>. 
 If a signal with this flag arrives and you have not set a signal stack,
 the system terminates the program with <code>SIGILL</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SA_RESTART</b><i>
-</i></td>
+<td align="left"><code>int <b>SA_RESTART</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This flag controls what happens when a signal is delivered during
 certain primitives (such as <code>open</code>, <code>read</code> or <code>write</code>),
 and the signal handler returns normally.  There are two alternatives:
@@ -59959,23 +58623,23 @@
 <p>The choice is controlled by the <code>SA_RESTART</code> flag for the
 particular kind of signal that was delivered.  If the flag is set,
 returning from a handler resumes the library function.  If the flag is
 clear, returning from a handler makes the function fail. 
-See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>. 
+See <a href="#Interrupted Primitives">Interrupted Primitives</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Initial%20Signal%20Actions">Initial Signal Actions</a>,
-Previous:<a rel=previous accesskey=p href="#Flags%20for%20Sigaction">Flags for Sigaction</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Actions">Signal Actions</a>
+Node:<a name="Initial Signal Actions">Initial Signal Actions</a>,
+Previous:<a rel=previous accesskey=p href="#Flags for Sigaction">Flags for Sigaction</a>,
+Up:<a rel=up accesskey=u href="#Signal Actions">Signal Actions</a>
 <br>
 
 <h4>Initial Signal Actions</h4>
 
-<p>When a new process is created (see <a href="#Creating%20a%20Process">Creating a Process</a>), it inherits
+<p>When a new process is created (see <a href="#Creating a Process">Creating a Process</a>), it inherits
 handling of signals from its parent process.  However, when you load a
-new process image using the <code>exec</code> function (see <a href="#Executing%20a%20File">Executing a File</a>), any signals that you've defined your own handlers for revert to
+new process image using the <code>exec</code> function (see <a href="#Executing a File">Executing a File</a>), any signals that you've defined your own handlers for revert to
 their <code>SIG_DFL</code> handling.  (If you think about it a little, this
 makes sense; the handler functions from the old program are specific to
 that program, and aren't even present in the address space of the new
 program image.)  Of course, the new program can establish its own
@@ -60003,12 +58667,12 @@
   }
 </pre>
 
 <p><hr>
-Node:<a name="Defining%20Handlers">Defining Handlers</a>,
-Next:<a rel=next accesskey=n href="#Interrupted%20Primitives">Interrupted Primitives</a>,
-Previous:<a rel=previous accesskey=p href="#Signal%20Actions">Signal Actions</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Defining Handlers">Defining Handlers</a>,
+Next:<a rel=next accesskey=n href="#Interrupted Primitives">Interrupted Primitives</a>,
+Previous:<a rel=previous accesskey=p href="#Signal Actions">Signal Actions</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Defining Signal Handlers</h3>
 
@@ -60018,9 +58682,9 @@
 <p>A signal handler is just a function that you compile together with the
 rest of the program.  Instead of directly invoking the function, you use
 <code>signal</code> or <code>sigaction</code> to tell the operating system to call
 it when a signal arrives.  This is known as <dfn>establishing</dfn> the
-handler.  See <a href="#Signal%20Actions">Signal Actions</a>.
+handler.  See <a href="#Signal Actions">Signal Actions</a>.
 
 <p>There are two basic strategies you can use in signal handler functions:
 
 <ul>
@@ -60038,27 +58702,27 @@
 very short interval, one handler can run within another.  This section
 describes what your handler should do, and what you should avoid.
 
 <ul>
-<li><a accesskey=1 href="#Handler%20Returns">Handler Returns</a>:              Handlers that return normally, and what
+<li><a accesskey=1 href="#Handler Returns">Handler Returns</a>:              Handlers that return normally, and what
                                  this means. 
-<li><a accesskey=2 href="#Termination%20in%20Handler">Termination in Handler</a>:       How handler functions terminate a program. 
-<li><a accesskey=3 href="#Longjmp%20in%20Handler">Longjmp in Handler</a>:           Nonlocal transfer of control out of a
+<li><a accesskey=2 href="#Termination in Handler">Termination in Handler</a>:       How handler functions terminate a program. 
+<li><a accesskey=3 href="#Longjmp in Handler">Longjmp in Handler</a>:           Nonlocal transfer of control out of a
                                  signal handler. 
-<li><a accesskey=4 href="#Signals%20in%20Handler">Signals in Handler</a>:           What happens when signals arrive while
+<li><a accesskey=4 href="#Signals in Handler">Signals in Handler</a>:           What happens when signals arrive while
                                  the handler is already occupied. 
-<li><a accesskey=5 href="#Merged%20Signals">Merged Signals</a>: 		When a second signal arrives before the
+<li><a accesskey=5 href="#Merged Signals">Merged Signals</a>: 		When a second signal arrives before the
 				 first is handled. 
 <li><a accesskey=6 href="#Nonreentrancy">Nonreentrancy</a>:                Do not call any functions unless you know they
                                  are reentrant with respect to signals. 
-<li><a accesskey=7 href="#Atomic%20Data%20Access">Atomic Data Access</a>:           A single handler can run in the middle of
+<li><a accesskey=7 href="#Atomic Data Access">Atomic Data Access</a>:           A single handler can run in the middle of
                                  reading or writing a single object. 
 </ul>
 
 <p><hr>
-Node:<a name="Handler%20Returns">Handler Returns</a>,
-Next:<a rel=next accesskey=n href="#Termination%20in%20Handler">Termination in Handler</a>,
-Up:<a rel=up accesskey=u href="#Defining%20Handlers">Defining Handlers</a>
+Node:<a name="Handler Returns">Handler Returns</a>,
+Next:<a rel=next accesskey=n href="#Termination in Handler">Termination in Handler</a>,
+Up:<a rel=up accesskey=u href="#Defining Handlers">Defining Handlers</a>
 <br>
 
 <h4>Signal Handlers that Return</h4>
 
@@ -60068,14 +58732,14 @@
 flag that tells the program to exit at a convenient time.
 
 <p>It is not safe to return normally from the handler for a program error
 signal, because the behavior of the program when the handler function
-returns is not defined after a program error.  See <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+returns is not defined after a program error.  See <a href="#Program Error Signals">Program Error Signals</a>.
 
 <p>Handlers that return normally must modify some global variable in order
 to have any effect.  Typically, the variable is one that is examined
 periodically by the program during normal operation.  Its data type
-should be <code>sig_atomic_t</code> for reasons described in <a href="#Atomic%20Data%20Access">Atomic Data Access</a>.
+should be <code>sig_atomic_t</code> for reasons described in <a href="#Atomic Data Access">Atomic Data Access</a>.
 
 <p>Here is a simple example of such a program.  It executes the body of
 the loop until it has noticed that a <code>SIGALRM</code> signal has arrived. 
 This technique is useful because it allows the iteration in progress
@@ -60121,12 +58785,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Termination%20in%20Handler">Termination in Handler</a>,
-Next:<a rel=next accesskey=n href="#Longjmp%20in%20Handler">Longjmp in Handler</a>,
-Previous:<a rel=previous accesskey=p href="#Handler%20Returns">Handler Returns</a>,
-Up:<a rel=up accesskey=u href="#Defining%20Handlers">Defining Handlers</a>
+Node:<a name="Termination in Handler">Termination in Handler</a>,
+Next:<a rel=next accesskey=n href="#Longjmp in Handler">Longjmp in Handler</a>,
+Previous:<a rel=previous accesskey=p href="#Handler Returns">Handler Returns</a>,
+Up:<a rel=up accesskey=u href="#Defining Handlers">Defining Handlers</a>
 <br>
 
 <h4>Handlers That Terminate the Process</h4>
 
@@ -60166,18 +58830,18 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Longjmp%20in%20Handler">Longjmp in Handler</a>,
-Next:<a rel=next accesskey=n href="#Signals%20in%20Handler">Signals in Handler</a>,
-Previous:<a rel=previous accesskey=p href="#Termination%20in%20Handler">Termination in Handler</a>,
-Up:<a rel=up accesskey=u href="#Defining%20Handlers">Defining Handlers</a>
+Node:<a name="Longjmp in Handler">Longjmp in Handler</a>,
+Next:<a rel=next accesskey=n href="#Signals in Handler">Signals in Handler</a>,
+Previous:<a rel=previous accesskey=p href="#Termination in Handler">Termination in Handler</a>,
+Up:<a rel=up accesskey=u href="#Defining Handlers">Defining Handlers</a>
 <br>
 
 <h4>Nonlocal Control Transfer in Handlers</h4>
 
 <p>You can do a nonlocal transfer of control out of a signal handler using
-the <code>setjmp</code> and <code>longjmp</code> facilities (see <a href="#Non-Local%20Exits">Non-Local Exits</a>).
+the <code>setjmp</code> and <code>longjmp</code> facilities (see <a href="#Non-Local Exits">Non-Local Exits</a>).
 
 <p>When the handler does a nonlocal control transfer, the part of the
 program that was running will not continue.  If this part of the program
 was in the middle of updating an important data structure, the data
@@ -60186,9 +58850,9 @@
 
 <p>There are two ways to avoid this problem.  One is to block the signal
 for the parts of the program that update important data structures. 
 Blocking the signal delays its delivery until it is unblocked, once the
-critical updating is finished.  See <a href="#Blocking%20Signals">Blocking Signals</a>.
+critical updating is finished.  See <a href="#Blocking Signals">Blocking Signals</a>.
 
 <p>The other way to re-initialize the crucial data structures in the signal
 handler, or make their values consistent.
 
@@ -60238,12 +58902,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Signals%20in%20Handler">Signals in Handler</a>,
-Next:<a rel=next accesskey=n href="#Merged%20Signals">Merged Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Longjmp%20in%20Handler">Longjmp in Handler</a>,
-Up:<a rel=up accesskey=u href="#Defining%20Handlers">Defining Handlers</a>
+Node:<a name="Signals in Handler">Signals in Handler</a>,
+Next:<a rel=next accesskey=n href="#Merged Signals">Merged Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Longjmp in Handler">Longjmp in Handler</a>,
+Up:<a rel=up accesskey=u href="#Defining Handlers">Defining Handlers</a>
 <br>
 
 <h4>Signals Arriving While a Handler Runs</h4>
 
@@ -60254,17 +58918,17 @@
 automatically blocked until the handler returns.  That means that if two
 signals of the same kind arrive close together, the second one will be
 held until the first has been handled.  (The handler can explicitly
 unblock the signal using <code>sigprocmask</code>, if you want to allow more
-signals of this type to arrive; see <a href="#Process%20Signal%20Mask">Process Signal Mask</a>.)
+signals of this type to arrive; see <a href="#Process Signal Mask">Process Signal Mask</a>.)
 
 <p>However, your handler can still be interrupted by delivery of another
 kind of signal.  To avoid this, you can use the <code>sa_mask</code> member of
 the action structure passed to <code>sigaction</code> to explicitly specify
 which signals should be blocked while the signal handler runs.  These
 signals are in addition to the signal for which the handler was invoked,
 and any other signals that are normally blocked by the process. 
-See <a href="#Blocking%20for%20Handler">Blocking for Handler</a>.
+See <a href="#Blocking for Handler">Blocking for Handler</a>.
 
 <p>When the handler returns, the set of blocked signals is restored to the
 value it had before the handler ran.  So using <code>sigprocmask</code> inside
 the handler only affects what signals can arrive during the execution of
@@ -60282,12 +58946,12 @@
 second signal would receive the default handling, which could terminate
 the process.
 
 <p><hr>
-Node:<a name="Merged%20Signals">Merged Signals</a>,
+Node:<a name="Merged Signals">Merged Signals</a>,
 Next:<a rel=next accesskey=n href="#Nonreentrancy">Nonreentrancy</a>,
-Previous:<a rel=previous accesskey=p href="#Signals%20in%20Handler">Signals in Handler</a>,
-Up:<a rel=up accesskey=u href="#Defining%20Handlers">Defining Handlers</a>
+Previous:<a rel=previous accesskey=p href="#Signals in Handler">Signals in Handler</a>,
+Up:<a rel=up accesskey=u href="#Defining Handlers">Defining Handlers</a>
 <br>
 
 <h4>Signals Close Together Merge into One</h4>
 
@@ -60410,9 +59074,9 @@
 until it sees that status has been validly stored.  This is to make sure
 that the status cannot change in the middle of accessing it.  Once
 <code>p-&gt;have_status</code> is set, it means that the child process is stopped
 or terminated, and in either case, it cannot stop or terminate again
-until the program has taken notice.  See <a href="#Atomic%20Usage">Atomic Usage</a>, for more
+until the program has taken notice.  See <a href="#Atomic Usage">Atomic Usage</a>, for more
 information about coping with interruptions during accesses of a
 variable.
 
 <p>Here is another way you can test whether the handler has run since the
@@ -60442,11 +59106,11 @@
 </pre>
 
 <p><hr>
 Node:<a name="Nonreentrancy">Nonreentrancy</a>,
-Next:<a rel=next accesskey=n href="#Atomic%20Data%20Access">Atomic Data Access</a>,
-Previous:<a rel=previous accesskey=p href="#Merged%20Signals">Merged Signals</a>,
-Up:<a rel=up accesskey=u href="#Defining%20Handlers">Defining Handlers</a>
+Next:<a rel=next accesskey=n href="#Atomic Data Access">Atomic Data Access</a>,
+Previous:<a rel=previous accesskey=p href="#Merged Signals">Merged Signals</a>,
+Up:<a rel=up accesskey=u href="#Defining Handlers">Defining Handlers</a>
 <br>
 
 <h4>Signal Handling and Nonreentrant Functions</h4>
 
@@ -60544,19 +59208,19 @@
 with any of the values that might appear in the object at a time when
 the signal can be delivered.  Keep in mind that assignment to some data
 types requires more than one instruction, which means that the handler
 could run "in the middle of" an assignment to the variable if its type
-is not atomic.  See <a href="#Atomic%20Data%20Access">Atomic Data Access</a>.
+is not atomic.  See <a href="#Atomic Data Access">Atomic Data Access</a>.
 
 <li>Merely writing into a memory object is safe as long as a sudden change
 in the value, at any time when the handler might run, will not disturb
 anything. 
 </ul>
 
 <p><hr>
-Node:<a name="Atomic%20Data%20Access">Atomic Data Access</a>,
+Node:<a name="Atomic Data Access">Atomic Data Access</a>,
 Previous:<a rel=previous accesskey=p href="#Nonreentrancy">Nonreentrancy</a>,
-Up:<a rel=up accesskey=u href="#Defining%20Handlers">Defining Handlers</a>
+Up:<a rel=up accesskey=u href="#Defining Handlers">Defining Handlers</a>
 <br>
 
 <h4>Atomic Data Access and Signal Handling</h4>
 
@@ -60569,20 +59233,20 @@
 <p>There are three ways you can cope with this problem.  You can use data
 types that are always accessed atomically; you can carefully arrange
 that nothing untoward happens if an access is interrupted, or you can
 block all signals around any access that had better not be interrupted
-(see <a href="#Blocking%20Signals">Blocking Signals</a>).
+(see <a href="#Blocking Signals">Blocking Signals</a>).
 
 <ul>
-<li><a accesskey=1 href="#Non-atomic%20Example">Non-atomic Example</a>: 		A program illustrating interrupted access. 
-<li><a accesskey=2 href="#Atomic%20Types">Types</a>: 		Data types that guarantee no interruption. 
-<li><a accesskey=3 href="#Atomic%20Usage">Usage</a>: 		Proving that interruption is harmless. 
+<li><a accesskey=1 href="#Non-atomic Example">Non-atomic Example</a>: 		A program illustrating interrupted access. 
+<li><a accesskey=2 href="#Atomic Types">Types</a>: 		Data types that guarantee no interruption. 
+<li><a accesskey=3 href="#Atomic Usage">Usage</a>: 		Proving that interruption is harmless. 
 </ul>
 
 <p><hr>
-Node:<a name="Non-atomic%20Example">Non-atomic Example</a>,
-Next:<a rel=next accesskey=n href="#Atomic%20Types">Atomic Types</a>,
-Up:<a rel=up accesskey=u href="#Atomic%20Data%20Access">Atomic Data Access</a>
+Node:<a name="Non-atomic Example">Non-atomic Example</a>,
+Next:<a rel=next accesskey=n href="#Atomic Types">Atomic Types</a>,
+Up:<a rel=up accesskey=u href="#Atomic Data Access">Atomic Data Access</a>
 <br>
 
 <h5>Problems with Non-Atomic Access</h5>
 
@@ -60635,12 +59299,12 @@
 <code>memory</code> with just one instruction that cannot be interrupted.  On
 these machines, the handler will always print two zeros or two ones.
 
 <p><hr>
-Node:<a name="Atomic%20Types">Atomic Types</a>,
-Next:<a rel=next accesskey=n href="#Atomic%20Usage">Atomic Usage</a>,
-Previous:<a rel=previous accesskey=p href="#Non-atomic%20Example">Non-atomic Example</a>,
-Up:<a rel=up accesskey=u href="#Atomic%20Data%20Access">Atomic Data Access</a>
+Node:<a name="Atomic Types">Atomic Types</a>,
+Next:<a rel=next accesskey=n href="#Atomic Usage">Atomic Usage</a>,
+Previous:<a rel=previous accesskey=p href="#Non-atomic Example">Non-atomic Example</a>,
+Up:<a rel=up accesskey=u href="#Atomic Data Access">Atomic Data Access</a>
 <br>
 
 <h5>Atomic Types</h5>
 
@@ -60654,16 +59318,15 @@
 one it is, and how many bits it contains, may vary from machine to
 machine.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>sig_atomic_t</b><i>
-</i></td>
+<td align="left"><code><b>sig_atomic_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an integer data type.  Objects of this type are always accessed
 atomically. 
 </td></tr>
@@ -60675,11 +59338,11 @@
 are true on all of the machines that the GNU C library supports and on
 all POSIX systems we know of.
 
 <p><hr>
-Node:<a name="Atomic%20Usage">Atomic Usage</a>,
-Previous:<a rel=previous accesskey=p href="#Atomic%20Types">Atomic Types</a>,
-Up:<a rel=up accesskey=u href="#Atomic%20Data%20Access">Atomic Data Access</a>
+Node:<a name="Atomic Usage">Atomic Usage</a>,
+Previous:<a rel=previous accesskey=p href="#Atomic Types">Atomic Types</a>,
+Up:<a rel=up accesskey=u href="#Atomic Data Access">Atomic Data Access</a>
 <br>
 
 <h5>Atomic Usage Patterns</h5>
 
@@ -60704,15 +59367,15 @@
 whether non-atomic usage is safe.)
 
 <p>Sometimes you can insure uninterrupted access to one object by
 protecting its use with another object, perhaps one whose type
-guarantees atomicity.  See <a href="#Merged%20Signals">Merged Signals</a>, for an example.
+guarantees atomicity.  See <a href="#Merged Signals">Merged Signals</a>, for an example.
 
 <p><hr>
-Node:<a name="Interrupted%20Primitives">Interrupted Primitives</a>,
-Next:<a rel=next accesskey=n href="#Generating%20Signals">Generating Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Defining%20Handlers">Defining Handlers</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Interrupted Primitives">Interrupted Primitives</a>,
+Next:<a rel=next accesskey=n href="#Generating Signals">Generating Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Defining Handlers">Defining Handlers</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Primitives Interrupted by Signals</h3>
 
@@ -60730,16 +59393,15 @@
 <p>The GNU library provides a convenient way to retry a call after a
 temporary failure, with the macro <code>TEMP_FAILURE_RETRY</code>:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>TEMP_FAILURE_RETRY</b><i> (<var>expression</var>)
-</i></td>
+<td align="left"><code><b>TEMP_FAILURE_RETRY</b><i> (<var>expression</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro evaluates <var>expression</var> once.  If it fails and reports
 error code <code>EINTR</code>, <code>TEMP_FAILURE_RETRY</code> evaluates it again,
 and over and over until the result is not a temporary failure.
@@ -60757,21 +59419,21 @@
 <p>You can choose either approach with the GNU library.  If you use
 <code>sigaction</code> to establish a signal handler, you can specify how that
 handler should behave.  If you specify the <code>SA_RESTART</code> flag,
 return from that handler will resume a primitive; otherwise, return from
-that handler will cause <code>EINTR</code>.  See <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>.
+that handler will cause <code>EINTR</code>.  See <a href="#Flags for Sigaction">Flags for Sigaction</a>.
 
 <p>Another way to specify the choice is with the <code>siginterrupt</code>
-function.  See <a href="#BSD%20Handler">BSD Handler</a>.
+function.  See <a href="#BSD Handler">BSD Handler</a>.
 
 <p>When you don't specify with <code>sigaction</code> or <code>siginterrupt</code> what
 a particular handler should do, it uses a default choice.  The default
 choice in the GNU library depends on the feature test macros you have
 defined.  If you define <code>_BSD_SOURCE</code> or <code>_GNU_SOURCE</code> before
 calling <code>signal</code>, the default is to resume primitives; otherwise,
 the default is to make them fail with <code>EINTR</code>.  (The library
 contains alternate versions of the <code>signal</code> function, and the
-feature test macros determine which one you really call.)  See <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+feature test macros determine which one you really call.)  See <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <p>The description of each primitive affected by this issue
 lists <code>EINTR</code> among the error codes it can return.
 
@@ -60789,12 +59451,12 @@
 transfer an entire record in one burst, with no waiting once data
 transfer has started.
 
 <p><hr>
-Node:<a name="Generating%20Signals">Generating Signals</a>,
-Next:<a rel=next accesskey=n href="#Blocking%20Signals">Blocking Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Interrupted%20Primitives">Interrupted Primitives</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Generating Signals">Generating Signals</a>,
+Next:<a rel=next accesskey=n href="#Blocking Signals">Blocking Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Interrupted Primitives">Interrupted Primitives</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Generating Signals</h3>
 
@@ -60802,34 +59464,33 @@
 interrupt, your program can explicitly send signals to itself or to
 another process.
 
 <ul>
-<li><a accesskey=1 href="#Signaling%20Yourself">Signaling Yourself</a>:           A process can send a signal to itself. 
-<li><a accesskey=2 href="#Signaling%20Another%20Process">Signaling Another Process</a>:    Send a signal to another process. 
-<li><a accesskey=3 href="#Permission%20for%20kill">Permission for kill</a>:          Permission for using <code>kill</code>. 
-<li><a accesskey=4 href="#Kill%20Example">Kill Example</a>:                 Using <code>kill</code> for Communication. 
+<li><a accesskey=1 href="#Signaling Yourself">Signaling Yourself</a>:           A process can send a signal to itself. 
+<li><a accesskey=2 href="#Signaling Another Process">Signaling Another Process</a>:    Send a signal to another process. 
+<li><a accesskey=3 href="#Permission for kill">Permission for kill</a>:          Permission for using <code>kill</code>. 
+<li><a accesskey=4 href="#Kill Example">Kill Example</a>:                 Using <code>kill</code> for Communication. 
 </ul>
 
 <p><hr>
-Node:<a name="Signaling%20Yourself">Signaling Yourself</a>,
-Next:<a rel=next accesskey=n href="#Signaling%20Another%20Process">Signaling Another Process</a>,
-Up:<a rel=up accesskey=u href="#Generating%20Signals">Generating Signals</a>
+Node:<a name="Signaling Yourself">Signaling Yourself</a>,
+Next:<a rel=next accesskey=n href="#Signaling Another Process">Signaling Another Process</a>,
+Up:<a rel=up accesskey=u href="#Generating Signals">Generating Signals</a>
 <br>
 
 <h4>Signaling Yourself</h4>
 
 <p>A process can send itself a signal with the <code>raise</code> function.  This
 function is declared in <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>raise</b><i> (int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>raise</b><i> (int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>raise</code> function sends the signal <var>signum</var> to the calling
 process.  It returns zero if successful and a nonzero value if it fails. 
 About the only reason for failure would be if the value of <var>signum</var>
@@ -60837,25 +59498,24 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>gsignal</b><i> (int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>gsignal</b><i> (int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>gsignal</code> function does the same thing as <code>raise</code>; it is
 provided only for compatibility with SVID. 
 </td></tr>
 </table>
 
 <p>One convenient use for <code>raise</code> is to reproduce the default behavior
 of a signal that you have trapped.  For instance, suppose a user of your
-program types the SUSP character (usually <kbd>C-z</kbd>; see <a href="#Special%20Characters">Special Characters</a>) to send it an interactive stop signal
+program types the SUSP character (usually <kbd>C-z</kbd>; see <a href="#Special Characters">Special Characters</a>) to send it an interactive stop signal
 (<code>SIGTSTP</code>), and you want to clean up some internal data buffers
 before stopping.  You might set this up like this:
 
 <br><pre>#include &lt;signal.h&gt;
@@ -60893,15 +59553,15 @@
 </pre>
 
 <p><strong>Portability note:</strong> <code>raise</code> was invented by the ISO&nbsp;C
 committee.  Older systems may not support it, so using <code>kill</code> may
-be more portable.  See <a href="#Signaling%20Another%20Process">Signaling Another Process</a>.
+be more portable.  See <a href="#Signaling Another Process">Signaling Another Process</a>.
 
 <p><hr>
-Node:<a name="Signaling%20Another%20Process">Signaling Another Process</a>,
-Next:<a rel=next accesskey=n href="#Permission%20for%20kill">Permission for kill</a>,
-Previous:<a rel=previous accesskey=p href="#Signaling%20Yourself">Signaling Yourself</a>,
-Up:<a rel=up accesskey=u href="#Generating%20Signals">Generating Signals</a>
+Node:<a name="Signaling Another Process">Signaling Another Process</a>,
+Next:<a rel=next accesskey=n href="#Permission for kill">Permission for kill</a>,
+Previous:<a rel=previous accesskey=p href="#Signaling Yourself">Signaling Yourself</a>,
+Up:<a rel=up accesskey=u href="#Generating Signals">Generating Signals</a>
 <br>
 
 <h4>Signaling Another Process</h4>
 
@@ -60926,20 +59586,19 @@
 
 <p>The <code>kill</code> function is declared in <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>kill</b><i> (pid_t <var>pid</var>, int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>kill</b><i> (pid_t <var>pid</var>, int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>kill</code> function sends the signal <var>signum</var> to the process
 or process group specified by <var>pid</var>.  Besides the signals listed in
-<a href="#Standard%20Signals">Standard Signals</a>, <var>signum</var> can also have a value of zero to
+<a href="#Standard Signals">Standard Signals</a>, <var>signum</var> can also have a value of zero to
 check the validity of the <var>pid</var>.
 
 <p>The <var>pid</var> specifies the process or process group to receive the
 signal:
@@ -60989,16 +59648,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>killpg</b><i> (int <var>pgid</var>, int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>killpg</b><i> (int <var>pgid</var>, int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>kill</code>, but sends signal <var>signum</var> to the
 process group <var>pgid</var>.  This function is provided for compatibility
 with BSD; using <code>kill</code> to do this is more portable. 
@@ -61007,12 +59665,12 @@
 
 <p>As a simple example of <code>kill</code>, the call <code>kill&nbsp;(getpid&nbsp;(),&nbsp;<var>sig</var>)</code> has the same effect as <code>raise&nbsp;(<var>sig</var>)</code>.
 
 <p><hr>
-Node:<a name="Permission%20for%20kill">Permission for kill</a>,
-Next:<a rel=next accesskey=n href="#Kill%20Example">Kill Example</a>,
-Previous:<a rel=previous accesskey=p href="#Signaling%20Another%20Process">Signaling Another Process</a>,
-Up:<a rel=up accesskey=u href="#Generating%20Signals">Generating Signals</a>
+Node:<a name="Permission for kill">Permission for kill</a>,
+Next:<a rel=next accesskey=n href="#Kill Example">Kill Example</a>,
+Previous:<a rel=previous accesskey=p href="#Signaling Another Process">Signaling Another Process</a>,
+Up:<a rel=up accesskey=u href="#Generating Signals">Generating Signals</a>
 <br>
 
 <h4>Permission for using <code>kill</code></h4>
 
@@ -61027,9 +59685,9 @@
 permission to send a signal.  The <code>su</code> program does this.
 
 <p>Whether a process has permission to send a signal to another process
 is determined by the user IDs of the two processes.  This concept is
-discussed in detail in <a href="#Process%20Persona">Process Persona</a>.
+discussed in detail in <a href="#Process Persona">Process Persona</a>.
 
 <p>Generally, for a process to be able to send a signal to another process,
 either the sending process must belong to a privileged user (like
 <code>root</code>), or the real or effective user ID of the sending process
@@ -61045,11 +59703,11 @@
 sender is part of the same session as the receiver, regardless of
 user IDs.
 
 <p><hr>
-Node:<a name="Kill%20Example">Kill Example</a>,
-Previous:<a rel=previous accesskey=p href="#Permission%20for%20kill">Permission for kill</a>,
-Up:<a rel=up accesskey=u href="#Generating%20Signals">Generating Signals</a>
+Node:<a name="Kill Example">Kill Example</a>,
+Previous:<a rel=previous accesskey=p href="#Permission for kill">Permission for kill</a>,
+Up:<a rel=up accesskey=u href="#Generating Signals">Generating Signals</a>
 <br>
 
 <h4>Using <code>kill</code> for Communication</h4>
 
@@ -61127,15 +59785,15 @@
 
 <p>This example uses a busy wait, which is bad, because it wastes CPU
 cycles that other programs could otherwise use.  It is better to ask the
 system to wait until the signal arrives.  See the example in
-<a href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>.
+<a href="#Waiting for a Signal">Waiting for a Signal</a>.
 
 <p><hr>
-Node:<a name="Blocking%20Signals">Blocking Signals</a>,
-Next:<a rel=next accesskey=n href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>,
-Previous:<a rel=previous accesskey=p href="#Generating%20Signals">Generating Signals</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Blocking Signals">Blocking Signals</a>,
+Next:<a rel=next accesskey=n href="#Waiting for a Signal">Waiting for a Signal</a>,
+Previous:<a rel=previous accesskey=p href="#Generating Signals">Generating Signals</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Blocking Signals</h3>
 
@@ -61155,28 +59813,28 @@
 signal handler can run without being interrupted itself by signals. 
 </ul>
 
 <ul>
-<li><a accesskey=1 href="#Why%20Block">Why Block</a>:                            The purpose of blocking signals. 
-<li><a accesskey=2 href="#Signal%20Sets">Signal Sets</a>:                          How to specify which signals to
+<li><a accesskey=1 href="#Why Block">Why Block</a>:                            The purpose of blocking signals. 
+<li><a accesskey=2 href="#Signal Sets">Signal Sets</a>:                          How to specify which signals to
                                          block. 
-<li><a accesskey=3 href="#Process%20Signal%20Mask">Process Signal Mask</a>:                  Blocking delivery of signals to your
+<li><a accesskey=3 href="#Process Signal Mask">Process Signal Mask</a>:                  Blocking delivery of signals to your
 				         process during normal execution. 
-<li><a accesskey=4 href="#Testing%20for%20Delivery">Testing for Delivery</a>:                 Blocking to Test for Delivery of
+<li><a accesskey=4 href="#Testing for Delivery">Testing for Delivery</a>:                 Blocking to Test for Delivery of
                                          a Signal. 
-<li><a accesskey=5 href="#Blocking%20for%20Handler">Blocking for Handler</a>:                 Blocking additional signals while a
+<li><a accesskey=5 href="#Blocking for Handler">Blocking for Handler</a>:                 Blocking additional signals while a
 				         handler is being run. 
-<li><a accesskey=6 href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>:         Checking for Pending Signals
-<li><a accesskey=7 href="#Remembering%20a%20Signal">Remembering a Signal</a>:                 How you can get almost the same
+<li><a accesskey=6 href="#Checking for Pending Signals">Checking for Pending Signals</a>:         Checking for Pending Signals
+<li><a accesskey=7 href="#Remembering a Signal">Remembering a Signal</a>:                 How you can get almost the same
                                          effect as blocking a signal, by
                                          handling it and setting a flag
                                          to be tested later. 
 </ul>
 
 <p><hr>
-Node:<a name="Why%20Block">Why Block</a>,
-Next:<a rel=next accesskey=n href="#Signal%20Sets">Signal Sets</a>,
-Up:<a rel=up accesskey=u href="#Blocking%20Signals">Blocking Signals</a>
+Node:<a name="Why Block">Why Block</a>,
+Next:<a rel=next accesskey=n href="#Signal Sets">Signal Sets</a>,
+Up:<a rel=up accesskey=u href="#Blocking Signals">Blocking Signals</a>
 <br>
 
 <h4>Why Blocking Signals is Useful</h4>
 
@@ -61186,9 +59844,9 @@
 unblock them.
 
 <p>One example where this is useful is for sharing data between a signal
 handler and the rest of the program.  If the type of the data is not
-<code>sig_atomic_t</code> (see <a href="#Atomic%20Data%20Access">Atomic Data Access</a>), then the signal
+<code>sig_atomic_t</code> (see <a href="#Atomic Data Access">Atomic Data Access</a>), then the signal
 handler could run when the rest of the program has only half finished
 reading or writing the data.  This would lead to confusing consequences.
 
 <p>To make the program reliable, you can prevent the signal handler from
@@ -61207,12 +59865,12 @@
 <p>The only way to test reliably for whether a signal has yet arrived is to
 test while the signal is blocked.
 
 <p><hr>
-Node:<a name="Signal%20Sets">Signal Sets</a>,
-Next:<a rel=next accesskey=n href="#Process%20Signal%20Mask">Process Signal Mask</a>,
-Previous:<a rel=previous accesskey=p href="#Why%20Block">Why Block</a>,
-Up:<a rel=up accesskey=u href="#Blocking%20Signals">Blocking Signals</a>
+Node:<a name="Signal Sets">Signal Sets</a>,
+Next:<a rel=next accesskey=n href="#Process Signal Mask">Process Signal Mask</a>,
+Previous:<a rel=previous accesskey=p href="#Why Block">Why Block</a>,
+Up:<a rel=up accesskey=u href="#Blocking Signals">Blocking Signals</a>
 <br>
 
 <h4>Signal Sets</h4>
 
@@ -61223,16 +59881,15 @@
 
 <p>These facilities are declared in the header file <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>sigset_t</b><i>
-</i></td>
+<td align="left"><code><b>sigset_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sigset_t</code> data type is used to represent a signal set. 
 Internally, it may be implemented as either an integer or structure
 type.
@@ -61256,46 +59913,43 @@
 assumption that the system has no signals aside from the ones you know
 about.)
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigemptyset</b><i> (sigset_t *<var>set</var>)
-</i></td>
+<td align="left"><code>int <b>sigemptyset</b><i> (sigset_t *<var>set</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function initializes the signal set <var>set</var> to exclude all of the
 defined signals.  It always returns <code>0</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigfillset</b><i> (sigset_t *<var>set</var>)
-</i></td>
+<td align="left"><code>int <b>sigfillset</b><i> (sigset_t *<var>set</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function initializes the signal set <var>set</var> to include
 all of the defined signals.  Again, the return value is <code>0</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigaddset</b><i> (sigset_t *<var>set</var>, int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>sigaddset</b><i> (sigset_t *<var>set</var>, int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function adds the signal <var>signum</var> to the signal set <var>set</var>. 
 All <code>sigaddset</code> does is modify <var>set</var>; it does not block or
 unblock any signals.
@@ -61310,16 +59964,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigdelset</b><i> (sigset_t *<var>set</var>, int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>sigdelset</b><i> (sigset_t *<var>set</var>, int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function removes the signal <var>signum</var> from the signal set
 <var>set</var>.  All <code>sigdelset</code> does is modify <var>set</var>; it does not
 block or unblock any signals.  The return value and error conditions are
@@ -61329,16 +59982,15 @@
 
 <p>Finally, there is a function to test what signals are in a signal set:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigismember</b><i> (const sigset_t *<var>set</var>, int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>sigismember</b><i> (const sigset_t *<var>set</var>, int <var>signum</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sigismember</code> function tests whether the signal <var>signum</var> is
 a member of the signal set <var>set</var>.  It returns <code>1</code> if the signal
 is in the set, <code>0</code> if not, and <code>-1</code> if there is an error.
@@ -61352,33 +60004,32 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Process%20Signal%20Mask">Process Signal Mask</a>,
-Next:<a rel=next accesskey=n href="#Testing%20for%20Delivery">Testing for Delivery</a>,
-Previous:<a rel=previous accesskey=p href="#Signal%20Sets">Signal Sets</a>,
-Up:<a rel=up accesskey=u href="#Blocking%20Signals">Blocking Signals</a>
+Node:<a name="Process Signal Mask">Process Signal Mask</a>,
+Next:<a rel=next accesskey=n href="#Testing for Delivery">Testing for Delivery</a>,
+Previous:<a rel=previous accesskey=p href="#Signal Sets">Signal Sets</a>,
+Up:<a rel=up accesskey=u href="#Blocking Signals">Blocking Signals</a>
 <br>
 
 <h4>Process Signal Mask</h4>
 
 <p>The collection of signals that are currently blocked is called the
 <dfn>signal mask</dfn>.  Each process has its own signal mask.  When you
-create a new process (see <a href="#Creating%20a%20Process">Creating a Process</a>), it inherits its
+create a new process (see <a href="#Creating a Process">Creating a Process</a>), it inherits its
 parent's mask.  You can block or unblock signals with total flexibility
 by modifying the signal mask.
 
 <p>The prototype for the <code>sigprocmask</code> function is in <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigprocmask</b><i> (int <var>how</var>, const sigset_t *restrict <var>set</var>, sigset_t *restrict <var>oldset</var>)
-</i></td>
+<td align="left"><code>int <b>sigprocmask</b><i> (int <var>how</var>, const sigset_t *restrict <var>set</var>, sigset_t *restrict <var>oldset</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sigprocmask</code> function is used to examine or change the calling
 process's signal mask.  The <var>how</var> argument determines how the signal
 mask is changed, and must be one of the following values:
@@ -61430,17 +60081,17 @@
 leads to undesirable results for signals generated by an actual program
 error (as opposed to signals sent with <code>raise</code> or <code>kill</code>). 
 This is because your program may be too broken to be able to continue
 executing to a point where the signal is unblocked again. 
-See <a href="#Program%20Error%20Signals">Program Error Signals</a>. 
+See <a href="#Program Error Signals">Program Error Signals</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Testing%20for%20Delivery">Testing for Delivery</a>,
-Next:<a rel=next accesskey=n href="#Blocking%20for%20Handler">Blocking for Handler</a>,
-Previous:<a rel=previous accesskey=p href="#Process%20Signal%20Mask">Process Signal Mask</a>,
-Up:<a rel=up accesskey=u href="#Blocking%20Signals">Blocking Signals</a>
+Node:<a name="Testing for Delivery">Testing for Delivery</a>,
+Next:<a rel=next accesskey=n href="#Blocking for Handler">Blocking for Handler</a>,
+Previous:<a rel=previous accesskey=p href="#Process Signal Mask">Process Signal Mask</a>,
+Up:<a rel=up accesskey=u href="#Blocking Signals">Blocking Signals</a>
 <br>
 
 <h4>Blocking to Test for Delivery of a Signal</h4>
 
@@ -61481,12 +60132,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Blocking%20for%20Handler">Blocking for Handler</a>,
-Next:<a rel=next accesskey=n href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>,
-Previous:<a rel=previous accesskey=p href="#Testing%20for%20Delivery">Testing for Delivery</a>,
-Up:<a rel=up accesskey=u href="#Blocking%20Signals">Blocking Signals</a>
+Node:<a name="Blocking for Handler">Blocking for Handler</a>,
+Next:<a rel=next accesskey=n href="#Checking for Pending Signals">Checking for Pending Signals</a>,
+Previous:<a rel=previous accesskey=p href="#Testing for Delivery">Testing for Delivery</a>,
+Up:<a rel=up accesskey=u href="#Blocking Signals">Blocking Signals</a>
 <br>
 
 <h4>Blocking Signals for a Handler</h4>
 
@@ -61548,34 +60199,33 @@
 those signals immediately, before returning to the code that was
 interrupted.
 
 <p><hr>
-Node:<a name="Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>,
-Next:<a rel=next accesskey=n href="#Remembering%20a%20Signal">Remembering a Signal</a>,
-Previous:<a rel=previous accesskey=p href="#Blocking%20for%20Handler">Blocking for Handler</a>,
-Up:<a rel=up accesskey=u href="#Blocking%20Signals">Blocking Signals</a>
+Node:<a name="Checking for Pending Signals">Checking for Pending Signals</a>,
+Next:<a rel=next accesskey=n href="#Remembering a Signal">Remembering a Signal</a>,
+Previous:<a rel=previous accesskey=p href="#Blocking for Handler">Blocking for Handler</a>,
+Up:<a rel=up accesskey=u href="#Blocking Signals">Blocking Signals</a>
 <br>
 
 <h4>Checking for Pending Signals</h4>
 
 <p>You can find out which signals are pending at any time by calling
 <code>sigpending</code>.  This function is declared in <code>signal.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigpending</b><i> (sigset_t *<var>set</var>)
-</i></td>
+<td align="left"><code>int <b>sigpending</b><i> (sigset_t *<var>set</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sigpending</code> function stores information about pending signals
 in <var>set</var>.  If there is a pending signal that is blocked from
 delivery, then that signal is a member of the returned set.  (You can
 test whether a particular signal is a member of this set using
-<code>sigismember</code>; see <a href="#Signal%20Sets">Signal Sets</a>.)
+<code>sigismember</code>; see <a href="#Signal Sets">Signal Sets</a>.)
 
 <p>The return value is <code>0</code> if successful, and <code>-1</code> on failure. 
 </td></tr>
 </table>
@@ -61617,11 +60267,11 @@
 <p><strong>Portability Note:</strong> The <code>sigpending</code> function is new in
 POSIX.1.  Older systems have no equivalent facility.
 
 <p><hr>
-Node:<a name="Remembering%20a%20Signal">Remembering a Signal</a>,
-Previous:<a rel=previous accesskey=p href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>,
-Up:<a rel=up accesskey=u href="#Blocking%20Signals">Blocking Signals</a>
+Node:<a name="Remembering a Signal">Remembering a Signal</a>,
+Previous:<a rel=previous accesskey=p href="#Checking for Pending Signals">Checking for Pending Signals</a>,
+Up:<a rel=up accesskey=u href="#Blocking Signals">Blocking Signals</a>
 <br>
 
 <h4>Remembering a Signal to Act On Later</h4>
 
@@ -61709,12 +60359,12 @@
 counter for <code>defer_signal</code>: it will reduce the chance you will
 write the code in the wrong order and create a subtle bug.)
 
 <p><hr>
-Node:<a name="Waiting%20for%20a%20Signal">Waiting for a Signal</a>,
-Next:<a rel=next accesskey=n href="#Signal%20Stack">Signal Stack</a>,
-Previous:<a rel=previous accesskey=p href="#Blocking%20Signals">Blocking Signals</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Waiting for a Signal">Waiting for a Signal</a>,
+Next:<a rel=next accesskey=n href="#Signal Stack">Signal Stack</a>,
+Previous:<a rel=previous accesskey=p href="#Blocking Signals">Blocking Signals</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Waiting for a Signal</h3>
 
@@ -61722,17 +60372,17 @@
 synchronization, then when it has nothing to do it should probably wait
 until a signal arrives.
 
 <ul>
-<li><a accesskey=1 href="#Using%20Pause">Using Pause</a>:                  The simple way, using <code>pause</code>. 
-<li><a accesskey=2 href="#Pause%20Problems">Pause Problems</a>:               Why the simple way is often not very good. 
+<li><a accesskey=1 href="#Using Pause">Using Pause</a>:                  The simple way, using <code>pause</code>. 
+<li><a accesskey=2 href="#Pause Problems">Pause Problems</a>:               Why the simple way is often not very good. 
 <li><a accesskey=3 href="#Sigsuspend">Sigsuspend</a>:                   Reliably waiting for a specific signal. 
 </ul>
 
 <p><hr>
-Node:<a name="Using%20Pause">Using Pause</a>,
-Next:<a rel=next accesskey=n href="#Pause%20Problems">Pause Problems</a>,
-Up:<a rel=up accesskey=u href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>
+Node:<a name="Using Pause">Using Pause</a>,
+Next:<a rel=next accesskey=n href="#Pause Problems">Pause Problems</a>,
+Up:<a rel=up accesskey=u href="#Waiting for a Signal">Waiting for a Signal</a>
 <br>
 
 <h4>Using <code>pause</code></h4>
 
@@ -61740,16 +60390,15 @@
 Please read about its disadvantages, in the following section, before
 you use it.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>pause</b><i> ()
-</i></td>
+<td align="left"><code>int <b>pause</b><i> ()</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pause</code> function suspends program execution until a signal
 arrives whose action is either to execute a handler function, or to
 terminate the process.
@@ -61757,9 +60406,9 @@
 <p>If the signal causes a handler function to be executed, then
 <code>pause</code> returns.  This is considered an unsuccessful return (since
 "successful" behavior would be to suspend the program forever), so the
 return value is <code>-1</code>.  Even if you specify that other primitives
-should resume when a system handler returns (see <a href="#Interrupted%20Primitives">Interrupted Primitives</a>), this has no effect on <code>pause</code>; it always fails when a
+should resume when a system handler returns (see <a href="#Interrupted Primitives">Interrupted Primitives</a>), this has no effect on <code>pause</code>; it always fails when a
 signal is handled.
 
 <p>The following <code>errno</code> error conditions are defined for this function:
 
@@ -61782,12 +60431,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Pause%20Problems">Pause Problems</a>,
+Node:<a name="Pause Problems">Pause Problems</a>,
 Next:<a rel=next accesskey=n href="#Sigsuspend">Sigsuspend</a>,
-Previous:<a rel=previous accesskey=p href="#Using%20Pause">Using Pause</a>,
-Up:<a rel=up accesskey=u href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>
+Previous:<a rel=previous accesskey=p href="#Using Pause">Using Pause</a>,
+Up:<a rel=up accesskey=u href="#Waiting for a Signal">Waiting for a Signal</a>
 <br>
 
 <h4>Problems with <code>pause</code></h4>
 
@@ -61834,10 +60483,10 @@
 run, using <code>sigsuspend</code>.
 
 <p><hr>
 Node:<a name="Sigsuspend">Sigsuspend</a>,
-Previous:<a rel=previous accesskey=p href="#Pause%20Problems">Pause Problems</a>,
-Up:<a rel=up accesskey=u href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>
+Previous:<a rel=previous accesskey=p href="#Pause Problems">Pause Problems</a>,
+Up:<a rel=up accesskey=u href="#Waiting for a Signal">Waiting for a Signal</a>
 <br>
 
 <h4>Using <code>sigsuspend</code></h4>
 
@@ -61846,16 +60495,15 @@
 you can wait for certain kinds of signals, while letting other kinds of
 signals be handled by their handlers.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigsuspend</b><i> (const sigset_t *<var>set</var>)
-</i></td>
+<td align="left"><code>int <b>sigsuspend</b><i> (const sigset_t *<var>set</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function replaces the process's signal mask with <var>set</var> and then
 suspends the process until a signal is delivered whose action is either
 to terminate the process or invoke a signal handling function.  In other
@@ -61914,12 +60562,12 @@
 just once for each kind of wait criterion you want to use.  The code
 that actually waits is just four lines.
 
 <p><hr>
-Node:<a name="Signal%20Stack">Signal Stack</a>,
-Next:<a rel=next accesskey=n href="#BSD%20Signal%20Handling">BSD Signal Handling</a>,
-Previous:<a rel=previous accesskey=p href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="Signal Stack">Signal Stack</a>,
+Next:<a rel=next accesskey=n href="#BSD Signal Handling">BSD Signal Handling</a>,
+Previous:<a rel=previous accesskey=p href="#Waiting for a Signal">Waiting for a Signal</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>Using a Separate Signal Stack</h3>
 
@@ -61944,16 +60592,15 @@
 not require your program to know which direction the stack grows, which
 depends on the specific machine and operating system.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>stack_t</b><i>
-</i></td>
+<td align="left"><code><b>stack_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure describes a signal stack.  It contains the following members:
 
 <dl>
@@ -62000,16 +60647,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigaltstack</b><i> (const stack_t *restrict <var>stack</var>, stack_t *restrict <var>oldstack</var>)
-</i></td>
+<td align="left"><code>int <b>sigaltstack</b><i> (const stack_t *restrict <var>stack</var>, stack_t *restrict <var>oldstack</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sigaltstack</code> function specifies an alternate stack for use
 during signal handling.  When a signal is received by the process and
 its action indicates that the signal stack is used, the system arranges
@@ -62038,16 +60684,15 @@
 <p>Here is the older <code>sigstack</code> interface.  You should use
 <code>sigaltstack</code> instead on systems that have it.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sigstack</b><i>
-</i></td>
+<td align="left"><code><b>struct sigstack</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure describes a signal stack.  It contains the following members:
 
 <dl>
@@ -62062,16 +60707,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigstack</b><i> (const struct sigstack *<var>stack</var>, struct sigstack *<var>oldstack</var>)
-</i></td>
+<td align="left"><code>int <b>sigstack</b><i> (const struct sigstack *<var>stack</var>, struct sigstack *<var>oldstack</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sigstack</code> function specifies an alternate stack for use during
 signal handling.  When a signal is received by the process and its
 action indicates that the signal stack is used, the system arranges a
@@ -62087,11 +60731,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="BSD%20Signal%20Handling">BSD Signal Handling</a>,
-Previous:<a rel=previous accesskey=p href="#Signal%20Stack">Signal Stack</a>,
-Up:<a rel=up accesskey=u href="#Signal%20Handling">Signal Handling</a>
+Node:<a name="BSD Signal Handling">BSD Signal Handling</a>,
+Previous:<a rel=previous accesskey=p href="#Signal Stack">Signal Stack</a>,
+Up:<a rel=up accesskey=u href="#Signal Handling">Signal Handling</a>
 <br>
 
 <h3>BSD Signal Handling</h3>
 
@@ -62112,38 +60756,37 @@
 <li>The BSD facilities use a different default for whether an interrupted
 primitive should fail or resume.  The POSIX facilities make system
 calls fail unless you specify that they should resume.  With the BSD
 facility, the default is to make system calls resume unless you say they
-should fail.  See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>. 
+should fail.  See <a href="#Interrupted Primitives">Interrupted Primitives</a>. 
 </ul>
 
 <p>The BSD facilities are declared in <code>signal.h</code>.
 
 <ul>
-<li><a accesskey=1 href="#BSD%20Handler">BSD Handler</a>:                  BSD Function to Establish a Handler. 
-<li><a accesskey=2 href="#Blocking%20in%20BSD">Blocking in BSD</a>:              BSD Functions for Blocking Signals. 
+<li><a accesskey=1 href="#BSD Handler">BSD Handler</a>:                  BSD Function to Establish a Handler. 
+<li><a accesskey=2 href="#Blocking in BSD">Blocking in BSD</a>:              BSD Functions for Blocking Signals. 
 </ul>
 
 <p><hr>
-Node:<a name="BSD%20Handler">BSD Handler</a>,
-Next:<a rel=next accesskey=n href="#Blocking%20in%20BSD">Blocking in BSD</a>,
-Up:<a rel=up accesskey=u href="#BSD%20Signal%20Handling">BSD Signal Handling</a>
+Node:<a name="BSD Handler">BSD Handler</a>,
+Next:<a rel=next accesskey=n href="#Blocking in BSD">Blocking in BSD</a>,
+Up:<a rel=up accesskey=u href="#BSD Signal Handling">BSD Signal Handling</a>
 <br>
 
 <h4>BSD Function to Establish a Handler</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct sigvec</b><i>
-</i></td>
+<td align="left"><code><b>struct sigvec</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type is the BSD equivalent of <code>struct sigaction</code>
-(see <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>); it is used to specify signal actions
+(see <a href="#Advanced Signal Handling">Advanced Signal Handling</a>); it is used to specify signal actions
 to the <code>sigvec</code> function.  It contains the following members:
 
 <dl>
 <dt><code>sighandler_t sv_handler</code>
@@ -62165,106 +60808,100 @@
 <code>sv_flags</code> field of a <code>sigvec</code> structure.  This field is a bit
 mask value, so you bitwise-OR the flags of interest to you together.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SV_ONSTACK</b><i>
-</i></td>
+<td align="left"><code>int <b>SV_ONSTACK</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set in the <code>sv_flags</code> field of a <code>sigvec</code>
 structure, it means to use the signal stack when delivering the signal. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SV_INTERRUPT</b><i>
-</i></td>
+<td align="left"><code>int <b>SV_INTERRUPT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set in the <code>sv_flags</code> field of a <code>sigvec</code>
 structure, it means that system calls interrupted by this kind of signal
 should not be restarted if the handler returns; instead, the system
-calls should return with a <code>EINTR</code> error status.  See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>. 
+calls should return with a <code>EINTR</code> error status.  See <a href="#Interrupted Primitives">Interrupted Primitives</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SV_RESETHAND</b><i>
-</i></td>
+<td align="left"><code>int <b>SV_RESETHAND</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this bit is set in the <code>sv_flags</code> field of a <code>sigvec</code>
 structure, it means to reset the action for the signal back to
 <code>SIG_DFL</code> when the signal is received. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigvec</b><i> (int <var>signum</var>, const struct sigvec *<var>action</var>,struct sigvec *<var>old-action</var>)
-</i></td>
+<td align="left"><code>int <b>sigvec</b><i> (int <var>signum</var>, const struct sigvec *<var>action</var>,struct sigvec *<var>old-action</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-This function is the equivalent of <code>sigaction</code> (see <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>); it installs the action <var>action</var> for the signal <var>signum</var>,
+This function is the equivalent of <code>sigaction</code> (see <a href="#Advanced Signal Handling">Advanced Signal Handling</a>); it installs the action <var>action</var> for the signal <var>signum</var>,
 returning information about the previous action in effect for that signal
 in <var>old-action</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>siginterrupt</b><i> (int <var>signum</var>, int <var>failflag</var>)
-</i></td>
+<td align="left"><code>int <b>siginterrupt</b><i> (int <var>signum</var>, int <var>failflag</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function specifies which approach to use when certain primitives
 are interrupted by handling signal <var>signum</var>.  If <var>failflag</var> is
 false, signal <var>signum</var> restarts primitives.  If <var>failflag</var> is
 true, handling <var>signum</var> causes these primitives to fail with error
-code <code>EINTR</code>.  See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>. 
+code <code>EINTR</code>.  See <a href="#Interrupted Primitives">Interrupted Primitives</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Blocking%20in%20BSD">Blocking in BSD</a>,
-Previous:<a rel=previous accesskey=p href="#BSD%20Handler">BSD Handler</a>,
-Up:<a rel=up accesskey=u href="#BSD%20Signal%20Handling">BSD Signal Handling</a>
+Node:<a name="Blocking in BSD">Blocking in BSD</a>,
+Previous:<a rel=previous accesskey=p href="#BSD Handler">BSD Handler</a>,
+Up:<a rel=up accesskey=u href="#BSD Signal Handling">BSD Signal Handling</a>
 <br>
 
 <h4>BSD Functions for Blocking Signals</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigmask</b><i> (int <var>signum</var>)
-</i></td>
+<td align="left"><code>int <b>sigmask</b><i> (int <var>signum</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a signal mask that has the bit for signal <var>signum</var>
 set.  You can bitwise-OR the results of several calls to <code>sigmask</code>
 together to specify more than one signal.  For example,
@@ -62277,59 +60914,56 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigblock</b><i> (int <var>mask</var>)
-</i></td>
+<td align="left"><code>int <b>sigblock</b><i> (int <var>mask</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-This function is equivalent to <code>sigprocmask</code> (see <a href="#Process%20Signal%20Mask">Process Signal Mask</a>) with a <var>how</var> argument of <code>SIG_BLOCK</code>: it adds the
+This function is equivalent to <code>sigprocmask</code> (see <a href="#Process Signal Mask">Process Signal Mask</a>) with a <var>how</var> argument of <code>SIG_BLOCK</code>: it adds the
 signals specified by <var>mask</var> to the calling process's set of blocked
 signals.  The return value is the previous set of blocked signals. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigsetmask</b><i> (int <var>mask</var>)
-</i></td>
+<td align="left"><code>int <b>sigsetmask</b><i> (int <var>mask</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-This function equivalent to <code>sigprocmask</code> (see <a href="#Process%20Signal%20Mask">Process Signal Mask</a>) with a <var>how</var> argument of <code>SIG_SETMASK</code>: it sets
+This function equivalent to <code>sigprocmask</code> (see <a href="#Process Signal Mask">Process Signal Mask</a>) with a <var>how</var> argument of <code>SIG_SETMASK</code>: it sets
 the calling process's signal mask to <var>mask</var>.  The return value is
 the previous set of blocked signals. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sigpause</b><i> (int <var>mask</var>)
-</i></td>
+<td align="left"><code>int <b>sigpause</b><i> (int <var>mask</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-This function is the equivalent of <code>sigsuspend</code> (see <a href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>):  it sets the calling process's signal mask to <var>mask</var>,
+This function is the equivalent of <code>sigsuspend</code> (see <a href="#Waiting for a Signal">Waiting for a Signal</a>):  it sets the calling process's signal mask to <var>mask</var>,
 and waits for a signal to arrive.  On return the previous set of blocked
 signals is restored. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Program%20Basics">Program Basics</a>,
+Node:<a name="Program Basics">Program Basics</a>,
 Next:<a rel=next accesskey=n href="#Processes">Processes</a>,
-Previous:<a rel=previous accesskey=p href="#Signal%20Handling">Signal Handling</a>,
+Previous:<a rel=previous accesskey=p href="#Signal Handling">Signal Handling</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>The Basic Program/System Interface</h2>
@@ -62358,21 +60992,21 @@
 system, and telling the system the program is done.
 
 <p>A program starts another program with the <code>exec</code> family of system calls. 
 This chapter looks at program startup from the execee's point of view.  To
-see the event from the execor's point of view, See <a href="#Executing%20a%20File">Executing a File</a>.
+see the event from the execor's point of view, See <a href="#Executing a File">Executing a File</a>.
 
 <ul>
-<li><a accesskey=1 href="#Program%20Arguments">Program Arguments</a>:            Parsing your program's command-line arguments. 
-<li><a accesskey=2 href="#Environment%20Variables">Environment Variables</a>:        Less direct parameters affecting your program
-<li><a accesskey=3 href="#System%20Calls">System Calls</a>:                 Requesting service from the system
-<li><a accesskey=4 href="#Program%20Termination">Program Termination</a>:          Telling the system you're done; return status
+<li><a accesskey=1 href="#Program Arguments">Program Arguments</a>:            Parsing your program's command-line arguments. 
+<li><a accesskey=2 href="#Environment Variables">Environment Variables</a>:        Less direct parameters affecting your program
+<li><a accesskey=3 href="#System Calls">System Calls</a>:                 Requesting service from the system
+<li><a accesskey=4 href="#Program Termination">Program Termination</a>:          Telling the system you're done; return status
 </ul>
 
 <p><hr>
-Node:<a name="Program%20Arguments">Program Arguments</a>,
-Next:<a rel=next accesskey=n href="#Environment%20Variables">Environment Variables</a>,
-Up:<a rel=up accesskey=u href="#Program%20Basics">Program Basics</a>
+Node:<a name="Program Arguments">Program Arguments</a>,
+Next:<a rel=next accesskey=n href="#Environment Variables">Environment Variables</a>,
+Up:<a rel=up accesskey=u href="#Program Basics">Program Basics</a>
 <br>
 
 <h3>Program Arguments</h3>
 
@@ -62411,21 +61045,21 @@
 </pre>
 
 <p>The first two arguments are just the same.  The third argument
 <var>envp</var> gives the program's environment; it is the same as the value
-of <code>environ</code>.  See <a href="#Environment%20Variables">Environment Variables</a>.  POSIX.1 does not
+of <code>environ</code>.  See <a href="#Environment Variables">Environment Variables</a>.  POSIX.1 does not
 allow this three-argument form, so to be portable it is best to write
 <code>main</code> to take two arguments, and use the value of <code>environ</code>.
 
 <ul>
-<li><a accesskey=1 href="#Argument%20Syntax">Argument Syntax</a>:              By convention, options start with a hyphen. 
-<li><a accesskey=2 href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>:    Ways to parse program options and arguments. 
+<li><a accesskey=1 href="#Argument Syntax">Argument Syntax</a>:              By convention, options start with a hyphen. 
+<li><a accesskey=2 href="#Parsing Program Arguments">Parsing Program Arguments</a>:    Ways to parse program options and arguments. 
 </ul>
 
 <p><hr>
-Node:<a name="Argument%20Syntax">Argument Syntax</a>,
-Next:<a rel=next accesskey=n href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>,
-Up:<a rel=up accesskey=u href="#Program%20Arguments">Program Arguments</a>
+Node:<a name="Argument Syntax">Argument Syntax</a>,
+Next:<a rel=next accesskey=n href="#Parsing Program Arguments">Parsing Program Arguments</a>,
+Up:<a rel=up accesskey=u href="#Program Arguments">Program Arguments</a>
 <br>
 
 <h4>Program Argument Syntax Conventions</h4>
 
@@ -62440,9 +61074,9 @@
 the options do not take arguments.  Thus, <code>-abc</code> is equivalent to
 <code>-a -b -c</code>.
 
 <li>Option names are single alphanumeric characters (as for <code>isalnum</code>;
-see <a href="#Classification%20of%20Characters">Classification of Characters</a>).
+see <a href="#Classification of Characters">Classification of Characters</a>).
 
 <li>Certain options require an argument.  For example, the <code>-o</code> command
 of the <code>ld</code> command requires an argument--an output file name.
 
@@ -62458,9 +61092,9 @@
 parsing, even if the user of your program intermixed option and
 non-option arguments.  They do this by reordering the elements of the
 <var>argv</var> array.  This behavior is nonstandard; if you want to suppress
 it, define the <code>_POSIX_OPTION_ORDER</code> environment variable. 
-See <a href="#Standard%20Environment">Standard Environment</a>.
+See <a href="#Standard Environment">Standard Environment</a>.
 
 </p><li>The argument <code>--</code> terminates all options; any following arguments
 are treated as non-option arguments, even if they begin with a hyphen.
 
@@ -62485,11 +61119,11 @@
 <p>Eventually, the GNU system will provide completion for long option names
 in the shell.
 
 <p><hr>
-Node:<a name="Parsing%20Program%20Arguments">Parsing Program Arguments</a>,
-Previous:<a rel=previous accesskey=p href="#Argument%20Syntax">Argument Syntax</a>,
-Up:<a rel=up accesskey=u href="#Program%20Arguments">Program Arguments</a>
+Node:<a name="Parsing Program Arguments">Parsing Program Arguments</a>,
+Previous:<a rel=previous accesskey=p href="#Argument Syntax">Argument Syntax</a>,
+Up:<a rel=up accesskey=u href="#Program Arguments">Program Arguments</a>
 <br>
 
 <h4>Parsing Program Arguments</h4>
 
@@ -62508,33 +61142,33 @@
 <ul>
 <li><a accesskey=1 href="#Getopt">Getopt</a>:                       Parsing program options using <code>getopt</code>. 
 <li><a accesskey=2 href="#Argp">Argp</a>:                         Parsing program options using <code>argp_parse</code>. 
 <li><a accesskey=3 href="#Suboptions">Suboptions</a>:                   Some programs need more detailed options. 
-<li><a accesskey=4 href="#Suboptions%20Example">Suboptions Example</a>:           This shows how it could be done for <code>mount</code>. 
+<li><a accesskey=4 href="#Suboptions Example">Suboptions Example</a>:           This shows how it could be done for <code>mount</code>. 
 </ul>
 
 <p><hr>
 Node:<a name="Getopt">Getopt</a>,
 Next:<a rel=next accesskey=n href="#Argp">Argp</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
+Up:<a rel=up accesskey=u href="#Parsing Program Arguments">Parsing Program Arguments</a>
 <br>
 
 <h3>Parsing program options using <code>getopt</code></h3>
 
 <p>The <code>getopt</code> and <code>getopt_long</code> functions automate some of the
 chore involved in parsing typical unix command line options.
 
 <ul>
-<li><a accesskey=1 href="#Using%20Getopt">Using Getopt</a>:                 Using the <code>getopt</code> function. 
-<li><a accesskey=2 href="#Example%20of%20Getopt">Example of Getopt</a>:            An example of parsing options with <code>getopt</code>. 
-<li><a accesskey=3 href="#Getopt%20Long%20Options">Getopt Long Options</a>:          GNU suggests utilities accept long-named
+<li><a accesskey=1 href="#Using Getopt">Using Getopt</a>:                 Using the <code>getopt</code> function. 
+<li><a accesskey=2 href="#Example of Getopt">Example of Getopt</a>:            An example of parsing options with <code>getopt</code>. 
+<li><a accesskey=3 href="#Getopt Long Options">Getopt Long Options</a>:          GNU suggests utilities accept long-named
                                  options; here is one way to do. 
-<li><a accesskey=4 href="#Getopt%20Long%20Option%20Example">Getopt Long Option Example</a>:   An example of using <code>getopt_long</code>. 
+<li><a accesskey=4 href="#Getopt Long Option Example">Getopt Long Option Example</a>:   An example of using <code>getopt_long</code>. 
 </ul>
 
 <p><hr>
-Node:<a name="Using%20Getopt">Using Getopt</a>,
-Next:<a rel=next accesskey=n href="#Example%20of%20Getopt">Example of Getopt</a>,
+Node:<a name="Using Getopt">Using Getopt</a>,
+Next:<a rel=next accesskey=n href="#Example of Getopt">Example of Getopt</a>,
 Up:<a rel=up accesskey=u href="#Getopt">Getopt</a>
 <br>
 
 <h4>Using the <code>getopt</code> function</h4>
@@ -62543,16 +61177,15 @@
 use this facility, your program must include the header file
 <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>opterr</b><i>
-</i></td>
+<td align="left"><code>int <b>opterr</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the value of this variable is nonzero, then <code>getopt</code> prints an
 error message to the standard error stream if it encounters an unknown
 option character or an option with a missing required argument.  This is
@@ -62562,16 +61195,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>optopt</b><i>
-</i></td>
+<td align="left"><code>int <b>optopt</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 When <code>getopt</code> encounters an unknown option character or an option
 with a missing required argument, it stores that option character in
 this variable.  You can use this for providing your own diagnostic
@@ -62579,16 +61211,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>optind</b><i>
-</i></td>
+<td align="left"><code>int <b>optind</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This variable is set by <code>getopt</code> to the index of the next element
 of the <var>argv</var> array to be processed.  Once <code>getopt</code> has found
 all of the option arguments, you can use this variable to determine
@@ -62597,31 +61228,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>optarg</b><i>
-</i></td>
+<td align="left"><code>char * <b>optarg</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This variable is set by <code>getopt</code> to point at the value of the
 option argument, for those options that accept arguments. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getopt</b><i> (int <var>argc</var>, char **<var>argv</var>, const char *<var>options</var>)
-</i></td>
+<td align="left"><code>int <b>getopt</b><i> (int <var>argc</var>, char **<var>argv</var>, const char *<var>options</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getopt</code> function gets the next option argument from the
 argument list specified by the <var>argv</var> and <var>argc</var> arguments. 
 Normally these values come directly from the arguments received by
@@ -62675,11 +61304,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Example%20of%20Getopt">Example of Getopt</a>,
-Next:<a rel=next accesskey=n href="#Getopt%20Long%20Options">Getopt Long Options</a>,
-Previous:<a rel=previous accesskey=p href="#Using%20Getopt">Using Getopt</a>,
+Node:<a name="Example of Getopt">Example of Getopt</a>,
+Next:<a rel=next accesskey=n href="#Getopt Long Options">Getopt Long Options</a>,
+Previous:<a rel=previous accesskey=p href="#Using Getopt">Using Getopt</a>,
 Up:<a rel=up accesskey=u href="#Getopt">Getopt</a>
 <br>
 
 <h4>Example of Parsing Arguments with <code>getopt</code></h4>
@@ -62727,12 +61356,12 @@
         cvalue = optarg;
         break;
       case '?':
         if (isprint (optopt))
-          fprintf (stderr, "Unknown option `-%c'.\n", optopt);
+          fprintf (stderr, "Unknown option '-%c'.\n", optopt);
         else
           fprintf (stderr,
-                   "Unknown option character `\\x%x'.\n",
+                   "Unknown option character '\\x%x'.\n",
                    optopt);
         return 1;
       default:
         abort ();
@@ -62786,11 +61415,11 @@
 Non-option argument -
 </pre>
 
 <p><hr>
-Node:<a name="Getopt%20Long%20Options">Getopt Long Options</a>,
-Next:<a rel=next accesskey=n href="#Getopt%20Long%20Option%20Example">Getopt Long Option Example</a>,
-Previous:<a rel=previous accesskey=p href="#Example%20of%20Getopt">Example of Getopt</a>,
+Node:<a name="Getopt Long Options">Getopt Long Options</a>,
+Next:<a rel=next accesskey=n href="#Getopt Long Option Example">Getopt Long Option Example</a>,
+Previous:<a rel=previous accesskey=p href="#Example of Getopt">Example of Getopt</a>,
 Up:<a rel=up accesskey=u href="#Getopt">Getopt</a>
 <br>
 
 <h4>Parsing Long Options with <code>getopt_long</code></h4>
@@ -62801,16 +61430,15 @@
 program accept long options if it uses any options, for this takes
 little extra work and helps beginners remember how to use the program.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct option</b><i>
-</i></td>
+<td align="left"><code><b>struct option</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure describes a single long option name for the sake of
 <code>getopt_long</code>.  The argument <var>longopts</var> must be an array of
 these structures, one for each long option.  Terminate the array with an
@@ -62843,16 +61471,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getopt_long</b><i> (int <var>argc</var>, char *const *<var>argv</var>, const char *<var>shortopts</var>, const struct option *<var>longopts</var>, int *<var>indexptr</var>)
-</i></td>
+<td align="left"><code>int <b>getopt_long</b><i> (int <var>argc</var>, char *const *<var>argv</var>, const char *<var>shortopts</var>, const struct option *<var>longopts</var>, int *<var>indexptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Decode options from the vector <var>argv</var> (whose length is <var>argc</var>). 
 The argument <var>shortopts</var> describes the short options to accept, just as
 it does in <code>getopt</code>.  The argument <var>longopts</var> describes the long
@@ -62904,16 +61531,15 @@
 <code>--option&nbsp;value</code>.  To enable these programs to use the GNU
 getopt functionality there is one more function available.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getopt_long_only</b><i> (int <var>argc</var>, char *const *<var>argv</var>, const char *<var>shortopts</var>, const struct option *<var>longopts</var>, int *<var>indexptr</var>)
-</i></td>
+<td align="left"><code>int <b>getopt_long_only</b><i> (int <var>argc</var>, char *const *<var>argv</var>, const char *<var>shortopts</var>, const struct option *<var>longopts</var>, int *<var>indexptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>getopt_long_only</code> function is equivalent to the
 <code>getopt_long</code> function but it allows to specify the user of the
@@ -62934,10 +61560,10 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Getopt%20Long%20Option%20Example">Getopt Long Option Example</a>,
-Previous:<a rel=previous accesskey=p href="#Getopt%20Long%20Options">Getopt Long Options</a>,
+Node:<a name="Getopt Long Option Example">Getopt Long Option Example</a>,
+Previous:<a rel=previous accesskey=p href="#Getopt Long Options">Getopt Long Options</a>,
 Up:<a rel=up accesskey=u href="#Getopt">Getopt</a>
 <br>
 
 <h4>Example of Parsing Long Options with <code>getopt_long</code></h4>
@@ -63004,17 +61630,17 @@
           puts ("option -b\n");
           break;
 
         case 'c':
-          printf ("option -c with value `%s'\n", optarg);
+          printf ("option -c with value '%s'\n", optarg);
           break;
 
         case 'd':
-          printf ("option -d with value `%s'\n", optarg);
+          printf ("option -d with value '%s'\n", optarg);
           break;
 
         case 'f':
-          printf ("option -f with value `%s'\n", optarg);
+          printf ("option -f with value '%s'\n", optarg);
           break;
 
         case '?':
           /* <code>getopt_long</code> already printed an error message. */
@@ -63047,15 +61673,15 @@
 <p><hr>
 Node:<a name="Argp">Argp</a>,
 Next:<a rel=next accesskey=n href="#Suboptions">Suboptions</a>,
 Previous:<a rel=previous accesskey=p href="#Getopt">Getopt</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
+Up:<a rel=up accesskey=u href="#Parsing Program Arguments">Parsing Program Arguments</a>
 <br>
 
 <h3>Parsing Program Options with Argp</h3>
 
 <p><dfn>Argp</dfn> is an interface for parsing unix-style argument vectors. 
-See <a href="#Program%20Arguments">Program Arguments</a>.
+See <a href="#Program Arguments">Program Arguments</a>.
 
 <p>Argp provides features unavailable in the more commonly used
 <code>getopt</code> interface.  These features include automatically producing
 output in response to the <code>--help</code> and <code>--version</code> options, as
@@ -63077,59 +61703,58 @@
 
 <p>The main interface to argp is the <code>argp_parse</code> function.  In many
 cases, calling <code>argp_parse</code> is the only argument-parsing code
 needed in <code>main</code>. 
-See <a href="#Program%20Arguments">Program Arguments</a>.
+See <a href="#Program Arguments">Program Arguments</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argp_parse</b><i> (const struct argp *<var>argp</var>, int <var>argc</var>, char **<var>argv</var>, unsigned <var>flags</var>, int *<var>arg_index</var>, void *<var>input</var>)
-</i></td>
+<td align="left"><code>error_t <b>argp_parse</b><i> (const struct argp *<var>argp</var>, int <var>argc</var>, char **<var>argv</var>, unsigned <var>flags</var>, int *<var>arg_index</var>, void *<var>input</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>argp_parse</code> function parses the arguments in <var>argv</var>, of
-length <var>argc</var>, using the argp parser <var>argp</var>.  See <a href="#Argp%20Parsers">Argp Parsers</a>.
+length <var>argc</var>, using the argp parser <var>argp</var>.  See <a href="#Argp Parsers">Argp Parsers</a>.
 
 <p>A value of zero is the same as a <code>struct argp</code>containing all
 zeros.  <var>flags</var> is a set of flag bits that modify the parsing
-behavior.  See <a href="#Argp%20Flags">Argp Flags</a>.  <var>input</var> is passed through to the argp
+behavior.  See <a href="#Argp Flags">Argp Flags</a>.  <var>input</var> is passed through to the argp
 parser <var>argp</var>, and has meaning defined by <var>argp</var>.  A typical
 usage is to pass a pointer to a structure which is used for specifying
 parameters to the parser and passing back the results.
 
 <p>Unless the <code>ARGP_NO_EXIT</code> or <code>ARGP_NO_HELP</code> flags are included
 in <var>flags</var>, calling <code>argp_parse</code> may result in the program
 exiting.  This behavior is true if an error is detected, or when an
-unknown option is encountered.  See <a href="#Program%20Termination">Program Termination</a>.
+unknown option is encountered.  See <a href="#Program Termination">Program Termination</a>.
 
 <p>If <var>arg_index</var> is non-null, the index of the first unparsed option
 in <var>argv</var> is returned as a value.
 
 <p>The return value is zero for successful parsing, or an error code
-(see <a href="#Error%20Codes">Error Codes</a>) if an error is detected.  Different argp parsers
+(see <a href="#Error Codes">Error Codes</a>) if an error is detected.  Different argp parsers
 may return arbitrary error codes, but the standard error codes are:
 <code>ENOMEM</code> if a memory allocation error occurred, or <code>EINVAL</code> if
 an unknown option or option argument is encountered. 
 </td></tr>
 </table>
 
 <ul>
-<li><a accesskey=1 href="#Argp%20Global%20Variables">Globals</a>:   Global argp parameters. 
-<li><a accesskey=2 href="#Argp%20Parsers">Parsers</a>:         Defining parsers for use with <code>argp_parse</code>. 
-<li><a accesskey=3 href="#Argp%20Flags">Flags</a>:             Flags that modify the behavior of <code>argp_parse</code>. 
-<li><a accesskey=4 href="#Argp%20Help">Help</a>:               Printing help messages when not parsing. 
-<li><a accesskey=5 href="#Argp%20Examples">Examples</a>:       Simple examples of programs using argp. 
-<li><a accesskey=6 href="#Argp%20User%20Customization">Customization</a>: 
+<li><a accesskey=1 href="#Argp Global Variables">Globals</a>:   Global argp parameters. 
+<li><a accesskey=2 href="#Argp Parsers">Parsers</a>:         Defining parsers for use with <code>argp_parse</code>. 
+<li><a accesskey=3 href="#Argp Flags">Flags</a>:             Flags that modify the behavior of <code>argp_parse</code>. 
+<li><a accesskey=4 href="#Argp Help">Help</a>:               Printing help messages when not parsing. 
+<li><a accesskey=5 href="#Argp Examples">Examples</a>:       Simple examples of programs using argp. 
+<li><a accesskey=6 href="#Argp User Customization">Customization</a>: 
                                 Users may control the <code>--help</code> output format. 
 </ul>
 
 <p><hr>
-Node:<a name="Argp%20Global%20Variables">Argp Global Variables</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Parsers">Argp Parsers</a>,
+Node:<a name="Argp Global Variables">Argp Global Variables</a>,
+Next:<a rel=next accesskey=n href="#Argp Parsers">Argp Parsers</a>,
 Up:<a rel=up accesskey=u href="#Argp">Argp</a>
 <br>
 
 <h4>Argp Global Variables</h4>
@@ -63138,16 +61763,15 @@
 <code>--version</code> option and provide a bug-reporting address in the
 <code>--help</code> output.  These are implemented in argp by default.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">const char * <b>argp_program_version</b><i>
-</i></td>
+<td align="left"><code>const char * <b>argp_program_version</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined or set by the user program to a non-zero value, then a
 <code>--version</code> option is added when parsing with <code>argp_parse</code>,
 which will print the <code>--version</code> string followed by a newline and
@@ -63155,16 +61779,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">const char * <b>argp_program_bug_address</b><i>
-</i></td>
+<td align="left"><code>const char * <b>argp_program_bug_address</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined or set by the user program to a non-zero value,
 <code>argp_program_bug_address</code> should point to a string that will be
 printed at the end of the standard output for the <code>--help</code> option,
@@ -63172,16 +61795,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>argp_program_version_hook</b><i>
-</i></td>
+<td align="left"><code><b>argp_program_version_hook</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined or set by the user program to a non-zero value, a
 <code>--version</code> option is added when parsing with <code>arg_parse</code>,
 which prints the program version and exits with a status of zero.  This
@@ -63194,36 +61816,35 @@
 
 <br><pre>void <var>print-version</var> (FILE *<var>stream</var>, struct argp_state *<var>state</var>)
 </pre>
 
-<p>See <a href="#Argp%20Parsing%20State">Argp Parsing State</a>, for an explanation of <var>state</var>.
+<p>See <a href="#Argp Parsing State">Argp Parsing State</a>, for an explanation of <var>state</var>.
 
 <p>This variable takes precedence over <code>argp_program_version</code>, and is
 useful if a program has version information not easily expressed in a
 simple string. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">error_t <b>argp_err_exit_status</b><i>
-</i></td>
+<td align="left"><code>error_t <b>argp_err_exit_status</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the exit status used when argp exits due to a parsing error.  If
 not defined or set by the user program, this defaults to:
 <code>EX_USAGE</code> from <code>&lt;sysexits.h&gt;</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Argp%20Parsers">Argp Parsers</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Flags">Argp Flags</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Global%20Variables">Argp Global Variables</a>,
+Node:<a name="Argp Parsers">Argp Parsers</a>,
+Next:<a rel=next accesskey=n href="#Argp Flags">Argp Flags</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Global Variables">Argp Global Variables</a>,
 Up:<a rel=up accesskey=u href="#Argp">Argp</a>
 <br>
 
 <h4>Specifying Argp Parsers</h4>
@@ -63231,16 +61852,15 @@
 <p>The first argument to the <code>argp_parse</code> function is a pointer to a
 <code>struct argp</code>, which is known as an <dfn>argp parser</dfn>:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct argp</b><i>
-</i></td>
+<td align="left"><code><b>struct argp</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure specifies how to parse a given set of options and
 arguments, perhaps in conjunction with other argp parsers.  It has the
 following fields:
@@ -63248,15 +61868,15 @@
 <dl>
 <dt><code>const struct argp_option *options</code>
 <dd>A pointer to a vector of <code>argp_option</code> structures specifying which
 options this argp parser understands; it may be zero if there are no
-options at all.  See <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>.
+options at all.  See <a href="#Argp Option Vectors">Argp Option Vectors</a>.
 
 <br><dt><code>argp_parser_t parser</code>
 <dd>A pointer to a function that defines actions for this parser; it is
 called for each option parsed, and at other well-defined points in the
 parsing process.  A value of zero is the same as a pointer to a function
-that always returns <code>ARGP_ERR_UNKNOWN</code>.  See <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>.
+that always returns <code>ARGP_ERR_UNKNOWN</code>.  See <a href="#Argp Parser Functions">Argp Parser Functions</a>.
 
 <br><dt><code>const char *args_doc</code>
 <dd>If non-zero, a string describing what non-option arguments are called by
 this parser.  This is only used to print the <code>Usage:</code> message.  If
@@ -63274,13 +61894,13 @@
 
 <br><dt><code>const struct argp_child *children</code>
 <dd>A pointer to a vector of <code>argp_children</code> structures.  This pointer
 specifies which additional argp parsers should be combined with this
-one.  See <a href="#Argp%20Children">Argp Children</a>.
+one.  See <a href="#Argp Children">Argp Children</a>.
 
 <br><dt><code>char *(*help_filter)(int <var>key</var>, const char *<var>text</var>, void *<var>input</var>)</code>
 <dd>If non-zero, a pointer to a function that filters the output of help
-messages.  See <a href="#Argp%20Help%20Filtering">Argp Help Filtering</a>.
+messages.  See <a href="#Argp Help Filtering">Argp Help Filtering</a>.
 
 <br><dt><code>const char *argp_domain</code>
 <dd>If non-zero, the strings used in the argp library are translated using
 the domain described by this string.  If zero, the current default domain
@@ -63298,19 +61918,19 @@
 most argp structures; the most-used fields are grouped near the
 beginning, the unused fields left unspecified.
 
 <ul>
-<li><a accesskey=1 href="#Argp%20Option%20Vectors">Options</a>:    Specifying options in an argp parser. 
-<li><a accesskey=2 href="#Argp%20Parser%20Functions">Argp Parser Functions</a>:          Defining actions for an argp parser. 
-<li><a accesskey=3 href="#Argp%20Children">Children</a>:         Combining multiple argp parsers. 
-<li><a accesskey=4 href="#Argp%20Help%20Filtering">Help Filtering</a>:   Customizing help output for an argp parser. 
+<li><a accesskey=1 href="#Argp Option Vectors">Options</a>:    Specifying options in an argp parser. 
+<li><a accesskey=2 href="#Argp Parser Functions">Argp Parser Functions</a>:          Defining actions for an argp parser. 
+<li><a accesskey=3 href="#Argp Children">Children</a>:         Combining multiple argp parsers. 
+<li><a accesskey=4 href="#Argp Help Filtering">Help Filtering</a>:   Customizing help output for an argp parser. 
 </ul>
 
 <p><hr>
-Node:<a name="Argp%20Option%20Vectors">Argp Option Vectors</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Parser%20Functions">Argp Parser Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Parsers">Argp Parsers</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Parsers">Argp Parsers</a>
+Node:<a name="Argp Option Vectors">Argp Option Vectors</a>,
+Next:<a rel=next accesskey=n href="#Argp Parser Functions">Argp Parser Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Parsers">Argp Parsers</a>,
+Up:<a rel=up accesskey=u href="#Argp Parsers">Argp Parsers</a>
 <br>
 
 <h4>Specifying Options in an Argp Parser</h4>
 
@@ -63321,16 +61941,15 @@
 entry with zero in all fields.  Note that when using an initialized C
 array for options, writing <code>{ 0 }</code> is enough to achieve this.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct argp_option</b><i>
-</i></td>
+<td align="left"><code><b>struct argp_option</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure specifies a single option that an argp parser
 understands, as well as how to parse and document that option.  It has
 the following fields:
@@ -63340,9 +61959,9 @@
 <dd>The long name for this option, corresponding to the long option
 <code>--<var>name</var></code>; this field may be zero if this option <em>only</em>
 has a short name.  To specify multiple names for an option, additional
 entries may follow this one, with the <code>OPTION_ALIAS</code> flag
-set.  See <a href="#Argp%20Option%20Flags">Argp Option Flags</a>.
+set.  See <a href="#Argp Option Flags">Argp Option Flags</a>.
 
 <br><dt><code>int key</code>
 <dd>The integer key provided by the current option to the option parser.  If
 <var>key</var> has a value that is a printable <small>ASCII</small> character (i.e.,
@@ -63353,13 +61972,13 @@
 <br><dt><code>const char *arg</code>
 <dd>If non-zero, this is the name of an argument associated with this
 option, which must be provided (e.g., with the
 <code>--<var>name</var>=<var>value</var></code> or <code>-<var>char</var> <var>value</var></code>
-syntaxes), unless the <code>OPTION_ARG_OPTIONAL</code> flag (see <a href="#Argp%20Option%20Flags">Argp Option Flags</a>) is set, in which case it <em>may</em> be provided.
+syntaxes), unless the <code>OPTION_ARG_OPTIONAL</code> flag (see <a href="#Argp Option Flags">Argp Option Flags</a>) is set, in which case it <em>may</em> be provided.
 
 <br><dt><code>int flags</code>
 <dd>Flags associated with this option, some of which are referred to above. 
-See <a href="#Argp%20Option%20Flags">Argp Option Flags</a>.
+See <a href="#Argp Option Flags">Argp Option Flags</a>.
 
 <br><dt><code>const char *doc</code>
 <dd>A documentation string for this option, for printing in help messages.
 
@@ -63388,14 +62007,14 @@
 </td></tr>
 </table>
 
 <ul>
-<li><a accesskey=1 href="#Argp%20Option%20Flags">Flags</a>:      Flags for options. 
+<li><a accesskey=1 href="#Argp Option Flags">Flags</a>:      Flags for options. 
 </ul>
 
 <p><hr>
-Node:<a name="Argp%20Option%20Flags">Argp Option Flags</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Option%20Vectors">Argp Option Vectors</a>
+Node:<a name="Argp Option Flags">Argp Option Flags</a>,
+Up:<a rel=up accesskey=u href="#Argp Option Vectors">Argp Option Vectors</a>
 <br>
 
 <h5>Flags for Argp Options</h5>
 
@@ -63431,30 +62050,30 @@
 after all options, after <code>OPTION_DOC</code> entries with a leading
 <code>-</code>, in the same group.
 
 <br><dt><code>OPTION_NO_USAGE</code>
-<dd>This option shouldn't be included in `long' usage messages, but should
+<dd>This option shouldn't be included in 'long' usage messages, but should
 still be included in other help messages.  This is intended for options
 that are completely documented in an argp's <code>args_doc</code>
-field.  See <a href="#Argp%20Parsers">Argp Parsers</a>.  Including this option in the generic usage
+field.  See <a href="#Argp Parsers">Argp Parsers</a>.  Including this option in the generic usage
 list would be redundant, and should be avoided.
 
 <p>For instance, if <code>args_doc</code> is <code>"FOO BAR\n-x BLAH"</code>, and the
 <code>-x</code> option's purpose is to distinguish these two cases, <code>-x</code>
 should probably be marked <code>OPTION_NO_USAGE</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Argp%20Parser%20Functions">Argp Parser Functions</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Children">Argp Children</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Option%20Vectors">Argp Option Vectors</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Parsers">Argp Parsers</a>
+Node:<a name="Argp Parser Functions">Argp Parser Functions</a>,
+Next:<a rel=next accesskey=n href="#Argp Children">Argp Children</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Option Vectors">Argp Option Vectors</a>,
+Up:<a rel=up accesskey=u href="#Argp Parsers">Argp Parsers</a>
 <br>
 
 <h4>Argp Parser Functions</h4>
 
 <p>The function pointed to by the <code>parser</code> field in a <code>struct
-argp</code> (see <a href="#Argp%20Parsers">Argp Parsers</a>) defines what actions take place in response
+argp</code> (see <a href="#Argp Parsers">Argp Parsers</a>) defines what actions take place in response
 to each option or argument parsed.  It is also used as a hook, allowing a
 parser to perform tasks at certain other points during parsing.
 
 <p>Argp parser functions have the following type signature:
@@ -63467,11 +62086,11 @@
 <dl>
 <dt><var>key</var>
 <dd>For each option that is parsed, <var>parser</var> is called with a value of
 <var>key</var> from that option's <code>key</code> field in the option
-vector.  See <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>.  <var>parser</var> is also called at
+vector.  See <a href="#Argp Option Vectors">Argp Option Vectors</a>.  <var>parser</var> is also called at
 other times with special reserved keys, such as <code>ARGP_KEY_ARG</code> for
-non-option arguments.  See <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+non-option arguments.  See <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><var>arg</var>
 <dd>If <var>key</var> is an option, <var>arg</var> is its given value.  This defaults
 to zero if no value is specified.  Only options that have a non-zero
@@ -63485,26 +62104,25 @@
 
 <br><dt><var>state</var>
 <dd><var>state</var> points to a <code>struct argp_state</code>, containing useful
 information about the current parsing state for use by
-<var>parser</var>.  See <a href="#Argp%20Parsing%20State">Argp Parsing State</a>. 
+<var>parser</var>.  See <a href="#Argp Parsing State">Argp Parsing State</a>. 
 </dl>
 
 <p>When <var>parser</var> is called, it should perform whatever action is
 appropriate for <var>key</var>, and return <code>0</code> for success,
 <code>ARGP_ERR_UNKNOWN</code> if the value of <var>key</var> is not handled by this
 parser function, or a unix error code if a real error
-occurred.  See <a href="#Error%20Codes">Error Codes</a>.
+occurred.  See <a href="#Error Codes">Error Codes</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ARGP_ERR_UNKNOWN</b><i>
-</i></td>
+<td align="left"><code>int <b>ARGP_ERR_UNKNOWN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Argp parser functions should return <code>ARGP_ERR_UNKNOWN</code> for any
 <var>key</var> value they do not recognize, or for non-option arguments
 (<code><var>key</var> == ARGP_KEY_ARG</code>) that they are not equipped to handle. 
@@ -63529,25 +62147,25 @@
 }
 </pre>
 
 <ul>
-<li><a accesskey=1 href="#Argp%20Special%20Keys">Keys</a>:            Special values for the <var>key</var> argument. 
-<li><a accesskey=2 href="#Argp%20Parsing%20State">State</a>:          What the <var>state</var> argument refers to. 
-<li><a accesskey=3 href="#Argp%20Helper%20Functions">Functions</a>:   Functions to help during argp parsing. 
+<li><a accesskey=1 href="#Argp Special Keys">Keys</a>:            Special values for the <var>key</var> argument. 
+<li><a accesskey=2 href="#Argp Parsing State">State</a>:          What the <var>state</var> argument refers to. 
+<li><a accesskey=3 href="#Argp Helper Functions">Functions</a>:   Functions to help during argp parsing. 
 </ul>
 
 <p><hr>
-Node:<a name="Argp%20Special%20Keys">Argp Special Keys</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Parsing%20State">Argp Parsing State</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Parser%20Functions">Argp Parser Functions</a>
+Node:<a name="Argp Special Keys">Argp Special Keys</a>,
+Next:<a rel=next accesskey=n href="#Argp Parsing State">Argp Parsing State</a>,
+Up:<a rel=up accesskey=u href="#Argp Parser Functions">Argp Parser Functions</a>
 <br>
 
 <h5>Special Keys for Argp Parser Functions</h5>
 
 <p>In addition to key values corresponding to user options, the <var>key</var>
 argument to argp parser functions may have a number of other special
 values.  In the following example <var>arg</var> and <var>state</var> refer to
-parser function arguments.  See <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>.
+parser function arguments.  See <a href="#Argp Parser Functions">Argp Parser Functions</a>.
 
 <dl>
 <dt><code>ARGP_KEY_ARG</code>
 <dd>This is not an option at all, but rather a command line argument, whose
@@ -63661,61 +62279,58 @@
 <code>ARGP_KEY_ERROR</code>.  No further calls are made, except the final call
 with <code>ARGP_KEY_FINI</code>.
 
 <p><hr>
-Node:<a name="Argp%20Helper%20Functions">Argp Helper Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Parsing%20State">Argp Parsing State</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Parser%20Functions">Argp Parser Functions</a>
+Node:<a name="Argp Helper Functions">Argp Helper Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Parsing State">Argp Parsing State</a>,
+Up:<a rel=up accesskey=u href="#Argp Parser Functions">Argp Parser Functions</a>
 <br>
 
 <h5>Functions For Use in Argp Parsers</h5>
 
 <p>Argp provides a number of functions available to the user of argp
-(see <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>), mostly for producing error messages. 
+(see <a href="#Argp Parser Functions">Argp Parser Functions</a>), mostly for producing error messages. 
 These take as their first argument the <var>state</var> argument to the
-parser function.  See <a href="#Argp%20Parsing%20State">Argp Parsing State</a>.
+parser function.  See <a href="#Argp Parsing State">Argp Parsing State</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>argp_usage</b><i> (const struct argp_state *<var>state</var>)
-</i></td>
+<td align="left"><code>void <b>argp_usage</b><i> (const struct argp_state *<var>state</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Outputs the standard usage message for the argp parser referred to by
 <var>state</var> to <code><var>state</var>-&gt;err_stream</code> and terminate the program
-with <code>exit (argp_err_exit_status)</code>.  See <a href="#Argp%20Global%20Variables">Argp Global Variables</a>. 
+with <code>exit (argp_err_exit_status)</code>.  See <a href="#Argp Global Variables">Argp Global Variables</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>argp_error</b><i> (const struct argp_state *<var>state</var>, const char *<var>fmt</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>argp_error</b><i> (const struct argp_state *<var>state</var>, const char *<var>fmt</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Prints the printf format string <var>fmt</var> and following args, preceded
 by the program name and <code>:</code>, and followed by a <code>Try&nbsp;<small>...</small>&nbsp;--help</code> message, and terminates the program with an exit status of
-<code>argp_err_exit_status</code>.  See <a href="#Argp%20Global%20Variables">Argp Global Variables</a>. 
+<code>argp_err_exit_status</code>.  See <a href="#Argp Global Variables">Argp Global Variables</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>argp_failure</b><i> (const struct argp_state *<var>state</var>, int <var>status</var>, int <var>errnum</var>, const char *<var>fmt</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>void <b>argp_failure</b><i> (const struct argp_state *<var>state</var>, int <var>status</var>, int <var>errnum</var>, const char *<var>fmt</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Similar to the standard gnu error-reporting function <code>error</code>, this
 prints the program name and <code>:</code>, the printf format string
 <var>fmt</var>, and the appropriate following args.  If it is non-zero, the
@@ -63730,29 +62345,28 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>argp_state_help</b><i> (const struct argp_state *<var>state</var>, FILE *<var>stream</var>, unsigned <var>flags</var>)
-</i></td>
+<td align="left"><code>void <b>argp_state_help</b><i> (const struct argp_state *<var>state</var>, FILE *<var>stream</var>, unsigned <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Outputs a help message for the argp parser referred to by <var>state</var>,
 to <var>stream</var>.  The <var>flags</var> argument determines what sort of help
-message is produced.  See <a href="#Argp%20Help%20Flags">Argp Help Flags</a>. 
+message is produced.  See <a href="#Argp Help Flags">Argp Help Flags</a>. 
 </td></tr>
 </table>
 
 <p>Error output is sent to <code><var>state</var>-&gt;err_stream</code>, and the program
 name printed is <code><var>state</var>-&gt;name</code>.
 
 <p>The output or program termination behavior of these functions may be
 suppressed if the <code>ARGP_NO_EXIT</code> or <code>ARGP_NO_ERRS</code> flags are
-passed to <code>argp_parse</code>.  See <a href="#Argp%20Flags">Argp Flags</a>.
+passed to <code>argp_parse</code>.  See <a href="#Argp Flags">Argp Flags</a>.
 
 <p>This behavior is useful if an argp parser is exported for use by other
 programs (e.g., by a library), and may be used in a context where it is
 not desirable to terminate the program in response to parsing errors.  In
@@ -63770,28 +62384,27 @@
 <p>If a parser function will <em>only</em> be used when <code>ARGP_NO_EXIT</code>
 is not set, the return may be omitted.
 
 <p><hr>
-Node:<a name="Argp%20Parsing%20State">Argp Parsing State</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Helper%20Functions">Argp Helper Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Special%20Keys">Argp Special Keys</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Parser%20Functions">Argp Parser Functions</a>
+Node:<a name="Argp Parsing State">Argp Parsing State</a>,
+Next:<a rel=next accesskey=n href="#Argp Helper Functions">Argp Helper Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Special Keys">Argp Special Keys</a>,
+Up:<a rel=up accesskey=u href="#Argp Parser Functions">Argp Parser Functions</a>
 <br>
 
 <h5>Argp Parsing State</h5>
 
-<p>The third argument to argp parser functions (see <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>) is a pointer to a <code>struct argp_state</code>, which contains
+<p>The third argument to argp parser functions (see <a href="#Argp Parser Functions">Argp Parser Functions</a>) is a pointer to a <code>struct argp_state</code>, which contains
 information about the state of the option parsing.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct argp_state</b><i>
-</i></td>
+<td align="left"><code><b>struct argp_state</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure has the following fields, which may be modified as noted:
 
 <dl>
@@ -63819,9 +62432,9 @@
 
 <br><dt><code>unsigned flags</code>
 <dd>The flags supplied to <code>argp_parse</code>.  These may be modified, although
 some flags may only take effect when <code>argp_parse</code> is first
-invoked.  See <a href="#Argp%20Flags">Argp Flags</a>.
+invoked.  See <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>unsigned arg_num</code>
 <dd>While calling a parsing function with the <var>key</var> argument
 <code>ARGP_KEY_ARG</code>, this represents the number of the current arg,
@@ -63844,9 +62457,9 @@
 be the same length as the number of children in the current parser.  Each
 child parser will be given the value of
 <code><var>state</var>-&gt;child_inputs[<var>i</var>]</code> as <em>its</em>
 <code><var>state</var>-&gt;input</code> field, where <var>i</var> is the index of the child
-in the this parser's <code>children</code> field.  See <a href="#Argp%20Children">Argp Children</a>.
+in the this parser's <code>children</code> field.  See <a href="#Argp Children">Argp Children</a>.
 
 <br><dt><code>void *hook</code>
 <dd>For the parser function's use.  Initialized to 0, but otherwise ignored
 by argp.
@@ -63860,21 +62473,21 @@
 <dt><code>FILE *out_stream</code>
 <dd>The stdio streams used when argp prints.  Error messages are printed to
 <code>err_stream</code>, all other output, such as <code>--help</code> output) to
 <code>out_stream</code>.  These are initialized to <code>stderr</code> and
-<code>stdout</code> respectively.  See <a href="#Standard%20Streams">Standard Streams</a>.
+<code>stdout</code> respectively.  See <a href="#Standard Streams">Standard Streams</a>.
 
 <br><dt><code>void *pstate</code>
 <dd>Private, for use by the argp implementation. 
 </dl>
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Argp%20Children">Argp Children</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Help%20Filtering">Argp Help Filtering</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Parser%20Functions">Argp Parser Functions</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Parsers">Argp Parsers</a>
+Node:<a name="Argp Children">Argp Children</a>,
+Next:<a rel=next accesskey=n href="#Argp Help Filtering">Argp Help Filtering</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Parser Functions">Argp Parser Functions</a>,
+Up:<a rel=up accesskey=u href="#Argp Parsers">Argp Parsers</a>
 <br>
 
 <h4>Combining Multiple Argp Parsers</h4>
 
@@ -63889,16 +62502,15 @@
 the parent argp parser(s), or the earlier of the argp parsers in the
 list of children.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct argp_child</b><i>
-</i></td>
+<td align="left"><code><b>struct argp_child</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An entry in the list of subsidiary argp parsers pointed to by the
 <code>children</code> field in a <code>struct argp</code>.  The fields are as
 follows:
@@ -63915,14 +62527,14 @@
 before the child options.  As a side-effect, a non-zero value forces the
 child options to be grouped together.  To achieve this effect without
 actually printing a header string, use a value of <code>""</code>.  As with
 header strings specified in an option entry, the conventional value of
-the last character is <code>:</code>.  See <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>.
+the last character is <code>:</code>.  See <a href="#Argp Option Vectors">Argp Option Vectors</a>.
 
 <br><dt><code>int group</code>
 <dd>This is where the child options are grouped relative to the other
-`consolidated' options in the parent argp parser.  The values are the
-same as the <code>group</code> field in <code>struct argp_option</code>.  See <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>.  All child-groupings follow parent options at a
+'consolidated' options in the parent argp parser.  The values are the
+same as the <code>group</code> field in <code>struct argp_option</code>.  See <a href="#Argp Option Vectors">Argp Option Vectors</a>.  All child-groupings follow parent options at a
 particular group level.  If both this field and <code>header</code> are zero,
 then the child's options aren't grouped together, they are merged with
 parent options at the parent option group level.
 
@@ -63930,11 +62542,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Argp%20Flags">Argp Flags</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Help">Argp Help</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Parsers">Argp Parsers</a>,
+Node:<a name="Argp Flags">Argp Flags</a>,
+Next:<a rel=next accesskey=n href="#Argp Help">Argp Help</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Parsers">Argp Parsers</a>,
 Up:<a rel=up accesskey=u href="#Argp">Argp</a>
 <br>
 
 <h4>Flags for <code>argp_parse</code></h4>
@@ -63962,9 +62574,9 @@
 <dd>Don't parse any non-option args.  Normally these are parsed by calling
 the parse functions with a key of <code>ARGP_KEY_ARG</code>, the actual
 argument being the value.  This flag needn't normally be set, as the
 default behavior is to stop parsing as soon as an argument fails to be
-parsed.  See <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>.
+parsed.  See <a href="#Argp Parser Functions">Argp Parser Functions</a>.
 
 <br><dt><code>ARGP_IN_ORDER</code>
 <dd>Parse options and arguments in the same order they occur on the command
 line.  Normally they're rearranged so that all options come first.
@@ -63977,9 +62589,9 @@
 <br><dt><code>ARGP_NO_EXIT</code>
 <dd>Don't exit on errors, although they may still result in error messages.
 
 <br><dt><code>ARGP_LONG_ONLY</code>
-<dd>Use the gnu getopt `long-only' rules for parsing arguments.  This allows
+<dd>Use the gnu getopt 'long-only' rules for parsing arguments.  This allows
 long-options to be recognized with only a single <code>-</code>
 (i.e.  <code>-help</code>).  This results in a less useful interface, and its
 use is discouraged as it conflicts with the way most GNU programs work
 as well as the GNU coding standards.
@@ -63989,11 +62601,11 @@
 <code>ARGP_NO_EXIT</code>, <code>ARGP_NO_ERRS</code>, and <code>ARGP_NO_HELP</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Argp%20Help%20Filtering">Argp Help Filtering</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Children">Argp Children</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Parsers">Argp Parsers</a>
+Node:<a name="Argp Help Filtering">Argp Help Filtering</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Children">Argp Children</a>,
+Up:<a rel=up accesskey=u href="#Argp Parsers">Argp Parsers</a>
 <br>
 
 <h4>Customizing Argp Help Output</h4>
 
@@ -64004,12 +62616,12 @@
 <br><pre>char *<var>help-filter</var> (int <var>key</var>, const char *<var>text</var>, void *<var>input</var>)
 </pre>
 
 <p>Where <var>key</var> is either a key from an option, in which case <var>text</var>
-is that option's help text.  See <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>.  Alternately, one
+is that option's help text.  See <a href="#Argp Option Vectors">Argp Option Vectors</a>.  Alternately, one
 of the special keys with names beginning with <code>ARGP_KEY_HELP_</code>
 might be used, describing which other help text <var>text</var> will contain. 
-See <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>.
+See <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>.
 
 <p>The function should return either <var>text</var> if it remains as-is, or a
 replacement string allocated using <code>malloc</code>.  This will be either be
 freed by argp or zero, which prints nothing.  The value of <var>text</var> is
@@ -64018,14 +62630,14 @@
 function.  <var>input</var> is either the input supplied to <code>argp_parse</code>
 or it is zero, if <code>argp_help</code> was called directly by the user.
 
 <ul>
-<li><a accesskey=1 href="#Argp%20Help%20Filter%20Keys">Keys</a>:   Special <var>key</var> values for help filter functions. 
+<li><a accesskey=1 href="#Argp Help Filter Keys">Keys</a>:   Special <var>key</var> values for help filter functions. 
 </ul>
 
 <p><hr>
-Node:<a name="Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Help%20Filtering">Argp Help Filtering</a>
+Node:<a name="Argp Help Filter Keys">Argp Help Filter Keys</a>,
+Up:<a rel=up accesskey=u href="#Argp Help Filtering">Argp Help Filtering</a>
 <br>
 
 <h5>Special Keys for Argp Help Filter Functions</h5>
 
@@ -64049,15 +62661,15 @@
 <br><dt><code>ARGP_KEY_HELP_DUP_ARGS_NOTE</code>
 <dd>The explanatory note printed when duplicate option arguments have been suppressed.
 
 <br><dt><code>ARGP_KEY_HELP_ARGS_DOC</code>
-<dd>The argument doc string; formally the <code>args_doc</code> field from the argp parser.  See <a href="#Argp%20Parsers">Argp Parsers</a>. 
+<dd>The argument doc string; formally the <code>args_doc</code> field from the argp parser.  See <a href="#Argp Parsers">Argp Parsers</a>. 
 </dl>
 
 <p><hr>
-Node:<a name="Argp%20Help">Argp Help</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Examples">Argp Examples</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Flags">Argp Flags</a>,
+Node:<a name="Argp Help">Argp Help</a>,
+Next:<a rel=next accesskey=n href="#Argp Examples">Argp Examples</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Flags">Argp Flags</a>,
 Up:<a rel=up accesskey=u href="#Argp">Argp</a>
 <br>
 
 <h4>The <code>argp_help</code> Function</h4>
@@ -64065,46 +62677,45 @@
 <p>Normally programs using argp need not be written with particular
 printing argument-usage-type help messages in mind as the standard
 <code>--help</code> option is handled automatically by argp.  Typical error
 cases can be handled using <code>argp_usage</code> and
-<code>argp_error</code>.  See <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>.  However, if it's
+<code>argp_error</code>.  See <a href="#Argp Helper Functions">Argp Helper Functions</a>.  However, if it's
 desirable to print a help message in some context other than parsing the
 program options, argp offers the <code>argp_help</code> interface.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>argp_help</b><i> (const struct argp *<var>argp</var>, FILE *<var>stream</var>, unsigned <var>flags</var>, char *<var>name</var>)
-</i></td>
+<td align="left"><code>void <b>argp_help</b><i> (const struct argp *<var>argp</var>, FILE *<var>stream</var>, unsigned <var>flags</var>, char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This outputs a help message for the argp parser <var>argp</var> to
 <var>stream</var>.  The type of messages printed will be determined by
 <var>flags</var>.
 
 <p>Any options such as <code>--help</code> that are implemented automatically by
 argp itself will <em>not</em> be present in the help output; for this
 reason it is best to use <code>argp_state_help</code> if calling from within
-an argp parser function.  See <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>. 
+an argp parser function.  See <a href="#Argp Helper Functions">Argp Helper Functions</a>. 
 </td></tr>
 </table>
 
 <ul>
-<li><a accesskey=1 href="#Argp%20Help%20Flags">Flags</a>:        Specifying what sort of help message to print. 
+<li><a accesskey=1 href="#Argp Help Flags">Flags</a>:        Specifying what sort of help message to print. 
 </ul>
 
 <p><hr>
-Node:<a name="Argp%20Help%20Flags">Argp Help Flags</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Help">Argp Help</a>
+Node:<a name="Argp Help Flags">Argp Help Flags</a>,
+Up:<a rel=up accesskey=u href="#Argp Help">Argp Help</a>
 <br>
 
 <h4>Flags for the <code>argp_help</code> Function</h4>
 
-<p>When calling <code>argp_help</code> (see <a href="#Argp%20Help">Argp Help</a>) or
-<code>argp_state_help</code> (see <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>) the exact output
+<p>When calling <code>argp_help</code> (see <a href="#Argp Help">Argp Help</a>) or
+<code>argp_state_help</code> (see <a href="#Argp Helper Functions">Argp Helper Functions</a>) the exact output
 is determined by the <var>flags</var> argument.  This should consist of any of
 the following flags, or'd together:
 
 <dl>
@@ -64172,29 +62783,29 @@
 terminates the program successfully. 
 </dl>
 
 <p><hr>
-Node:<a name="Argp%20Examples">Argp Examples</a>,
-Next:<a rel=next accesskey=n href="#Argp%20User%20Customization">Argp User Customization</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Help">Argp Help</a>,
+Node:<a name="Argp Examples">Argp Examples</a>,
+Next:<a rel=next accesskey=n href="#Argp User Customization">Argp User Customization</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Help">Argp Help</a>,
 Up:<a rel=up accesskey=u href="#Argp">Argp</a>
 <br>
 
 <h4>Argp Examples</h4>
 
 <p>These example programs demonstrate the basic usage of argp.
 
 <ul>
-<li><a accesskey=1 href="#Argp%20Example%201">1</a>:             A minimal program using argp. 
-<li><a accesskey=2 href="#Argp%20Example%202">2</a>:             A program using only default options. 
-<li><a accesskey=3 href="#Argp%20Example%203">3</a>:             A simple program with user options. 
-<li><a accesskey=4 href="#Argp%20Example%204">4</a>:             Combining multiple argp parsers. 
+<li><a accesskey=1 href="#Argp Example 1">1</a>:             A minimal program using argp. 
+<li><a accesskey=2 href="#Argp Example 2">2</a>:             A program using only default options. 
+<li><a accesskey=3 href="#Argp Example 3">3</a>:             A simple program with user options. 
+<li><a accesskey=4 href="#Argp Example 4">4</a>:             Combining multiple argp parsers. 
 </ul>
 
 <p><hr>
-Node:<a name="Argp%20Example%201">Argp Example 1</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Example%202">Argp Example 2</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Examples">Argp Examples</a>
+Node:<a name="Argp Example 1">Argp Example 1</a>,
+Next:<a rel=next accesskey=n href="#Argp Example 2">Argp Example 2</a>,
+Up:<a rel=up accesskey=u href="#Argp Examples">Argp Examples</a>
 <br>
 
 <h5>A Minimal Program Using Argp</h5>
 
@@ -64220,12 +62831,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Argp%20Example%202">Argp Example 2</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Example%203">Argp Example 3</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Example%201">Argp Example 1</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Examples">Argp Examples</a>
+Node:<a name="Argp Example 2">Argp Example 2</a>,
+Next:<a rel=next accesskey=n href="#Argp Example 3">Argp Example 3</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Example 1">Argp Example 1</a>,
+Up:<a rel=up accesskey=u href="#Argp Examples">Argp Examples</a>
 <br>
 
 <h5>A Program Using Argp with Only Default Options</h5>
 
@@ -64295,27 +62906,27 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Argp%20Example%203">Argp Example 3</a>,
-Next:<a rel=next accesskey=n href="#Argp%20Example%204">Argp Example 4</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Example%202">Argp Example 2</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Examples">Argp Examples</a>
+Node:<a name="Argp Example 3">Argp Example 3</a>,
+Next:<a rel=next accesskey=n href="#Argp Example 4">Argp Example 4</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Example 2">Argp Example 2</a>,
+Up:<a rel=up accesskey=u href="#Argp Examples">Argp Examples</a>
 <br>
 
 <h5>A Program Using Argp with User Options</h5>
 
 <p>This program uses the same features as example 2, adding user options
 and arguments.
 
-<p>We now use the first four fields in <code>argp</code> (see <a href="#Argp%20Parsers">Argp Parsers</a>)
-and specify <code>parse_opt</code> as the parser function.  See <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>.
+<p>We now use the first four fields in <code>argp</code> (see <a href="#Argp Parsers">Argp Parsers</a>)
+and specify <code>parse_opt</code> as the parser function.  See <a href="#Argp Parser Functions">Argp Parser Functions</a>.
 
 <p>Note that in this example, <code>main</code> uses a structure to communicate
 with the <code>parse_opt</code> function, a pointer to which it passes in the
 <code>input</code> argument to <code>argp_parse</code>.  See <a href="#Argp">Argp</a>.  It is retrieved
 by <code>parse_opt</code> through the <code>input</code> field in its <code>state</code>
-argument.  See <a href="#Argp%20Parsing%20State">Argp Parsing State</a>.  Of course, it's also possible to
+argument.  See <a href="#Argp Parsing State">Argp Parsing State</a>.  Of course, it's also possible to
 use global variables instead, but using a structure like this is
 somewhat more flexible and clean.
 
 <br><pre>
@@ -64474,28 +63085,28 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Argp%20Example%204">Argp Example 4</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Example%203">Argp Example 3</a>,
-Up:<a rel=up accesskey=u href="#Argp%20Examples">Argp Examples</a>
+Node:<a name="Argp Example 4">Argp Example 4</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Example 3">Argp Example 3</a>,
+Up:<a rel=up accesskey=u href="#Argp Examples">Argp Examples</a>
 <br>
 
 <h5>A Program Using Multiple Combined Argp Parsers</h5>
 
 <p>This program uses the same features as example 3, but has more options,
 and presents more structure in the <code>--help</code> output.  It also
-illustrates how you can `steal' the remainder of the input arguments
+illustrates how you can 'steal' the remainder of the input arguments
 past a certain point for programs that accept a list of items.  It also
 illustrates the <var>key</var> value <code>ARGP_KEY_NO_ARGS</code>, which is only
 given if no non-option arguments were supplied to the
-program.  See <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+program.  See <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <p>For structuring help output, two features are used: <em>headers</em> and a
 two part option string.  The <em>headers</em> are entries in the options
-vector.  See <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>.  The first four fields are zero.  The
+vector.  See <a href="#Argp Option Vectors">Argp Option Vectors</a>.  The first four fields are zero.  The
 two part documentation string are in the variable <code>doc</code>, which
-allows documentation both before and after the options.  See <a href="#Argp%20Parsers">Argp Parsers</a>, the two parts of <code>doc</code> are separated by a vertical-tab
+allows documentation both before and after the options.  See <a href="#Argp Parsers">Argp Parsers</a>, the two parts of <code>doc</code> are separated by a vertical-tab
 character (<code>'\v'</code>, or <code>'\013'</code>).  By convention, the
 documentation before the options is a short string stating what the
 program does, and after any options it is longer, describing the
 behavior in more detail.  All documentation strings are automatically
@@ -64509,9 +63120,9 @@
 /* Argp example #4 - a program with somewhat more complicated options */
 
 /* This program uses the same features as example 3, but has more
    options, and somewhat more structure in the -help output.  It
-   also shows how you can `steal' the remainder of the input
+   also shows how you can 'steal' the remainder of the input
    arguments past a certain point, for programs that accept a
    list of items.  It also shows the special argp KEY value
    ARGP_KEY_NO_ARGS, which is only given if no non-option
    arguments were supplied to the program.
@@ -64527,9 +63138,9 @@
    is longer, describing the behavior in more detail.  All
    documentation strings are automatically filled for output,
    although newlines may be included to force a line break at a
    particular point.  All documentation strings are also passed to
-   the `gettext' function, for possible translation into the
+   the 'gettext' function, for possible translation into the
    current locale. */
 
 #include &lt;stdlib.h&gt;
 #include &lt;error.h&gt;
@@ -64675,10 +63286,10 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Argp%20User%20Customization">Argp User Customization</a>,
-Previous:<a rel=previous accesskey=p href="#Argp%20Examples">Argp Examples</a>,
+Node:<a name="Argp User Customization">Argp User Customization</a>,
+Previous:<a rel=previous accesskey=p href="#Argp Examples">Argp Examples</a>,
 Up:<a rel=up accesskey=u href="#Argp">Argp</a>
 <br>
 
 <h4>Argp User Customization</h4>
@@ -64709,9 +63320,9 @@
 <br><dt><code>long-opt-col=<var>n</var></code>
 <dd>This prints the first long option in column <var>n</var>.  The default is 6.
 
 <br><dt><code>doc-opt-col=<var>n</var></code>
-<dd>This prints `documentation options' (see <a href="#Argp%20Option%20Flags">Argp Option Flags</a>) in
+<dd>This prints 'documentation options' (see <a href="#Argp Option Flags">Argp Option Flags</a>) in
 column <var>n</var>.  The default is 2.
 
 <br><dt><code>opt-doc-col=<var>n</var></code>
 <dd>This prints the documentation for options starting in column
@@ -64731,11 +63342,11 @@
 </dl>
 
 <p><hr>
 Node:<a name="Suboptions">Suboptions</a>,
-Next:<a rel=next accesskey=n href="#Suboptions%20Example">Suboptions Example</a>,
+Next:<a rel=next accesskey=n href="#Suboptions Example">Suboptions Example</a>,
 Previous:<a rel=previous accesskey=p href="#Argp">Argp</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
+Up:<a rel=up accesskey=u href="#Parsing Program Arguments">Parsing Program Arguments</a>
 <br>
 
 <h5>Parsing of Suboptions</h5>
 
@@ -64749,16 +63360,15 @@
 programming of code like this the function <code>getsubopt</code> is
 available.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getsubopt</b><i> (char **<var>optionp</var>, const char* const *<var>tokens</var>, char **<var>valuep</var>)
-</i></td>
+<td align="left"><code>int <b>getsubopt</b><i> (char **<var>optionp</var>, const char* const *<var>tokens</var>, char **<var>valuep</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <var>optionp</var> parameter must be a pointer to a variable containing
 the address of the string to process.  When the function returns the
@@ -64786,11 +63396,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Suboptions%20Example">Suboptions Example</a>,
+Node:<a name="Suboptions Example">Suboptions Example</a>,
 Previous:<a rel=previous accesskey=p href="#Suboptions">Suboptions</a>,
-Up:<a rel=up accesskey=u href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
+Up:<a rel=up accesskey=u href="#Parsing Program Arguments">Parsing Program Arguments</a>
 <br>
 
 <h4>Parsing of Suboptions Example</h4>
 
@@ -64864,9 +63474,9 @@
               write_size = atoi (value);
               break;
             default:
               /* Unknown suboption. */
-              printf ("Unknown suboption `%s'\n", value);
+              printf ("Unknown suboption '%s'\n", value);
               break;
             }
         break;
       default:
@@ -64879,20 +63489,20 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Environment%20Variables">Environment Variables</a>,
-Next:<a rel=next accesskey=n href="#System%20Calls">System Calls</a>,
-Previous:<a rel=previous accesskey=p href="#Program%20Arguments">Program Arguments</a>,
-Up:<a rel=up accesskey=u href="#Program%20Basics">Program Basics</a>
+Node:<a name="Environment Variables">Environment Variables</a>,
+Next:<a rel=next accesskey=n href="#System Calls">System Calls</a>,
+Previous:<a rel=previous accesskey=p href="#Program Arguments">Program Arguments</a>,
+Up:<a rel=up accesskey=u href="#Program Basics">Program Basics</a>
 <br>
 
 <h3>Environment Variables</h3>
 
 <p>When a program is executed, it receives information about the context in
 which it was invoked in two ways.  The first mechanism uses the
 <var>argv</var> and <var>argc</var> arguments to its <code>main</code> function, and is
-discussed in <a href="#Program%20Arguments">Program Arguments</a>.  The second mechanism uses
+discussed in <a href="#Program Arguments">Program Arguments</a>.  The second mechanism uses
 <dfn>environment variables</dfn> and is discussed in this section.
 
 <p>The <var>argv</var> mechanism is typically used to pass command-line
 arguments specific to the particular program being invoked.  The
@@ -64919,18 +63529,18 @@
 represented as a string.  A value must not contain an embedded null
 character, since this is assumed to terminate the string.
 
 <ul>
-<li><a accesskey=1 href="#Environment%20Access">Environment Access</a>:           How to get and set the values of
+<li><a accesskey=1 href="#Environment Access">Environment Access</a>:           How to get and set the values of
 				 environment variables. 
-<li><a accesskey=2 href="#Standard%20Environment">Standard Environment</a>:         These environment variables have
+<li><a accesskey=2 href="#Standard Environment">Standard Environment</a>:         These environment variables have
                 		 standard interpretations. 
 </ul>
 
 <p><hr>
-Node:<a name="Environment%20Access">Environment Access</a>,
-Next:<a rel=next accesskey=n href="#Standard%20Environment">Standard Environment</a>,
-Up:<a rel=up accesskey=u href="#Environment%20Variables">Environment Variables</a>
+Node:<a name="Environment Access">Environment Access</a>,
+Next:<a rel=next accesskey=n href="#Standard Environment">Standard Environment</a>,
+Up:<a rel=up accesskey=u href="#Environment Variables">Environment Variables</a>
 <br>
 
 <h4>Environment Access</h4>
 
@@ -64940,16 +63550,15 @@
 multi-threaded programs.  It is made sure that concurrent modifications
 to the environment do not lead to errors.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>getenv</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>char * <b>getenv</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a string that is the value of the environment
 variable <var>name</var>.  You must not modify this string.  In some non-Unix
 systems not using the GNU library, it might be overwritten by subsequent
@@ -64959,16 +63568,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>putenv</b><i> (char *<var>string</var>)
-</i></td>
+<td align="left"><code>int <b>putenv</b><i> (char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>putenv</code> function adds or removes definitions from the environment. 
 If the <var>string</var> is of the form <code><var>name</var>=<var>value</var></code>, the
 definition is added to the environment.  Otherwise, the <var>string</var> is
@@ -64989,16 +63597,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setenv</b><i> (const char *<var>name</var>, const char *<var>value</var>, int <var>replace</var>)
-</i></td>
+<td align="left"><code>int <b>setenv</b><i> (const char *<var>name</var>, const char *<var>value</var>, int <var>replace</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>setenv</code> function can be used to add a new definition to the
 environment.  The entry with the name <var>name</var> is replaced by the
 value <code><var>name</var>=<var>value</var></code>.  Please note that this is also true
@@ -65016,16 +63623,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>unsetenv</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>int <b>unsetenv</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Using this function one can remove an entry completely from the
 environment.  If the environment contains an entry with the key
 <var>name</var> this whole entry is removed.  A call to this function is
@@ -65047,16 +63653,15 @@
 never happened.  But we still provide this function as a GNU extension
 to enable writing standard compliant Fortran environments.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>clearenv</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>clearenv</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>clearenv</code> function removes all entries from the environment. 
 Using <code>putenv</code> and <code>setenv</code> new entries can be added again
 later.
@@ -65068,19 +63673,18 @@
 
 <p>You can deal directly with the underlying representation of environment
 objects to add more variables to the environment (for example, to
 communicate with another program you are about to execute;
-see <a href="#Executing%20a%20File">Executing a File</a>).
+see <a href="#Executing a File">Executing a File</a>).
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char ** <b>environ</b><i>
-</i></td>
+<td align="left"><code>char ** <b>environ</b><i></i></code></td>
 <td align="right">Variable</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The environment is represented as an array of strings.  Each string is
 of the format <code><var>name</var>=<var>value</var></code>.  The order in which
 strings appear in the environment is not significant, but the same
@@ -65095,14 +63699,14 @@
 </table>
 
 <p>Unix systems, and the GNU system, pass the initial value of
 <code>environ</code> as the third argument to <code>main</code>. 
-See <a href="#Program%20Arguments">Program Arguments</a>.
+See <a href="#Program Arguments">Program Arguments</a>.
 
 <p><hr>
-Node:<a name="Standard%20Environment">Standard Environment</a>,
-Previous:<a rel=previous accesskey=p href="#Environment%20Access">Environment Access</a>,
-Up:<a rel=up accesskey=u href="#Environment%20Variables">Environment Variables</a>
+Node:<a name="Standard Environment">Standard Environment</a>,
+Previous:<a rel=previous accesskey=p href="#Environment Access">Environment Access</a>,
+Up:<a rel=up accesskey=u href="#Environment Variables">Environment Variables</a>
 <br>
 
 <h4>Standard Environment Variables</h4>
 
@@ -65120,9 +63724,9 @@
 
 <p>The user can set <code>HOME</code> to any value. 
 If you need to make sure to obtain the proper home directory
 for a particular user, you should not use <code>HOME</code>; instead,
-look up the user's name in the user database (see <a href="#User%20Database">User Database</a>).
+look up the user's name in the user database (see <a href="#User Database">User Database</a>).
 
 <p>For most purposes, it is better to use <code>HOME</code>, precisely because
 this lets the user specify the value.
 
@@ -65131,9 +63735,9 @@
 
 <p>This is the name that the user used to log in.  Since the value in the
 environment can be tweaked arbitrarily, this is not a reliable way to
 identify the user who is running a program; a function like
-<code>getlogin</code> (see <a href="#Who%20Logged%20In">Who Logged In</a>) is better for that purpose.
+<code>getlogin</code> (see <a href="#Who Logged In">Who Logged In</a>) is better for that purpose.
 
 <p>For most purposes, it is better to use <code>LOGNAME</code>, precisely because
 this lets the user specify the value.
 
@@ -65143,15 +63747,15 @@
 <p>A <dfn>path</dfn> is a sequence of directory names which is used for
 searching for a file.  The variable <code>PATH</code> holds a path used
 for searching for programs to be run.
 
-<p>The <code>execlp</code> and <code>execvp</code> functions (see <a href="#Executing%20a%20File">Executing a File</a>)
+<p>The <code>execlp</code> and <code>execvp</code> functions (see <a href="#Executing a File">Executing a File</a>)
 use this environment variable, as do many shells and other utilities
 which are implemented in terms of those functions.
 
 <p>The syntax of a path is a sequence of directory names separated by
 colons.  An empty string instead of a directory name stands for the
-current directory (see <a href="#Working%20Directory">Working Directory</a>).
+current directory (see <a href="#Working Directory">Working Directory</a>).
 
 <p>A typical value for this environment variable might be a string like:
 
 <br><pre>:/bin:/etc:/usr/bin:/usr/new/X11:/usr/new:/usr/local/bin
@@ -65168,14 +63772,14 @@
 <p>This specifies the kind of terminal that is receiving program output. 
 Some programs can make use of this information to take advantage of
 special escape sequences or terminal modes supported by particular kinds
 of terminals.  Many programs which use the termcap library
-(see <a href="termcap.html#Finding%20a%20Terminal%20Description">Find</a>) use the <code>TERM</code> environment variable, for example.
+(see <a href="termcap.html#Finding a Terminal Description">Find</a>) use the <code>TERM</code> environment variable, for example.
 
 <br><dt><code>TZ</code>
 <dd>
 
-<p>This specifies the time zone.  See <a href="#TZ%20Variable">TZ Variable</a>, for information about
+<p>This specifies the time zone.  See <a href="#TZ Variable">TZ Variable</a>, for information about
 the format of this string and how it is used.
 
 <br><dt><code>LANG</code>
 <dd>
@@ -65235,17 +63839,17 @@
 <dd>
 
 <p>If this environment variable is defined, it suppresses the usual
 reordering of command line arguments by <code>getopt</code> and
-<code>argp_parse</code>.  See <a href="#Argument%20Syntax">Argument Syntax</a>.
+<code>argp_parse</code>.  See <a href="#Argument Syntax">Argument Syntax</a>.
 
 </dl>
 
 <p><hr>
-Node:<a name="System%20Calls">System Calls</a>,
-Next:<a rel=next accesskey=n href="#Program%20Termination">Program Termination</a>,
-Previous:<a rel=previous accesskey=p href="#Environment%20Variables">Environment Variables</a>,
-Up:<a rel=up accesskey=u href="#Program%20Basics">Program Basics</a>
+Node:<a name="System Calls">System Calls</a>,
+Next:<a rel=next accesskey=n href="#Program Termination">Program Termination</a>,
+Previous:<a rel=previous accesskey=p href="#Environment Variables">Environment Variables</a>,
+Up:<a rel=up accesskey=u href="#Program Basics">Program Basics</a>
 <br>
 
 <h3>System Calls</h3>
 
@@ -65283,16 +63887,15 @@
 
 <p><code>syscall</code> is declared in <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>syscall</b><i> (long int <var>sysno</var>, ...)
-</i></td>
+<td align="left"><code>long int <b>syscall</b><i> (long int <var>sysno</var>, ...)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>syscall</code> performs a generic system call.
 
@@ -65353,11 +63956,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Program%20Termination">Program Termination</a>,
-Previous:<a rel=previous accesskey=p href="#System%20Calls">System Calls</a>,
-Up:<a rel=up accesskey=u href="#Program%20Basics">Program Basics</a>
+Node:<a name="Program Termination">Program Termination</a>,
+Previous:<a rel=previous accesskey=p href="#System Calls">System Calls</a>,
+Up:<a rel=up accesskey=u href="#Program Basics">Program Basics</a>
 <br>
 
 <h3>Program Termination</h3>
 
@@ -65369,27 +63972,27 @@
 <p>A program can also terminate normally by calling the <code>exit</code>
 function.
 
 <p>In addition, programs can be terminated by signals; this is discussed in
-more detail in <a href="#Signal%20Handling">Signal Handling</a>.  The <code>abort</code> function causes
+more detail in <a href="#Signal Handling">Signal Handling</a>.  The <code>abort</code> function causes
 a signal that kills the program.
 
 <ul>
-<li><a accesskey=1 href="#Normal%20Termination">Normal Termination</a>:           If a program calls <code>exit</code>, a
+<li><a accesskey=1 href="#Normal Termination">Normal Termination</a>:           If a program calls <code>exit</code>, a
                                  process terminates normally. 
-<li><a accesskey=2 href="#Exit%20Status">Exit Status</a>:                  The <code>exit status</code> provides information
+<li><a accesskey=2 href="#Exit Status">Exit Status</a>:                  The <code>exit status</code> provides information
                                  about why the process terminated. 
-<li><a accesskey=3 href="#Cleanups%20on%20Exit">Cleanups on Exit</a>:             A process can run its own cleanup
+<li><a accesskey=3 href="#Cleanups on Exit">Cleanups on Exit</a>:             A process can run its own cleanup
                                  functions upon normal termination. 
-<li><a accesskey=4 href="#Aborting%20a%20Program">Aborting a Program</a>:           The <code>abort</code> function causes
+<li><a accesskey=4 href="#Aborting a Program">Aborting a Program</a>:           The <code>abort</code> function causes
                                  abnormal program termination. 
-<li><a accesskey=5 href="#Termination%20Internals">Termination Internals</a>:        What happens when a process terminates. 
+<li><a accesskey=5 href="#Termination Internals">Termination Internals</a>:        What happens when a process terminates. 
 </ul>
 
 <p><hr>
-Node:<a name="Normal%20Termination">Normal Termination</a>,
-Next:<a rel=next accesskey=n href="#Exit%20Status">Exit Status</a>,
-Up:<a rel=up accesskey=u href="#Program%20Termination">Program Termination</a>
+Node:<a name="Normal Termination">Normal Termination</a>,
+Next:<a rel=next accesskey=n href="#Exit Status">Exit Status</a>,
+Up:<a rel=up accesskey=u href="#Program Termination">Program Termination</a>
 <br>
 
 <h4>Normal Termination</h4>
 
@@ -65398,16 +64001,15 @@
 calling <code>exit</code>, and the value that <code>main</code> returns is used as
 the argument to <code>exit</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>exit</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>void <b>exit</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>exit</code> function tells the system that the program is done, which
 causes it to terminate the process.
 
@@ -65426,19 +64028,19 @@
 things like saving program state information in a file, or unlocking
 locks in shared data bases.
 
 <li>All open streams are closed, writing out any buffered output data.  See
-<a href="#Closing%20Streams">Closing Streams</a>.  In addition, temporary files opened
-with the <code>tmpfile</code> function are removed; see <a href="#Temporary%20Files">Temporary Files</a>.
+<a href="#Closing Streams">Closing Streams</a>.  In addition, temporary files opened
+with the <code>tmpfile</code> function are removed; see <a href="#Temporary Files">Temporary Files</a>.
 
-<li><code>_exit</code> is called, terminating the program.  See <a href="#Termination%20Internals">Termination Internals</a>.
+<li><code>_exit</code> is called, terminating the program.  See <a href="#Termination Internals">Termination Internals</a>.
 </ol>
 
 <p><hr>
-Node:<a name="Exit%20Status">Exit Status</a>,
-Next:<a rel=next accesskey=n href="#Cleanups%20on%20Exit">Cleanups on Exit</a>,
-Previous:<a rel=previous accesskey=p href="#Normal%20Termination">Normal Termination</a>,
-Up:<a rel=up accesskey=u href="#Program%20Termination">Program Termination</a>
+Node:<a name="Exit Status">Exit Status</a>,
+Next:<a rel=next accesskey=n href="#Cleanups on Exit">Cleanups on Exit</a>,
+Previous:<a rel=previous accesskey=p href="#Normal Termination">Normal Termination</a>,
+Up:<a rel=up accesskey=u href="#Program Termination">Program Termination</a>
 <br>
 
 <h4>Exit Status</h4>
 
@@ -65480,16 +64082,15 @@
 conventional status value for success and failure, respectively.  They
 are declared in the file <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EXIT_SUCCESS</b><i>
-</i></td>
+<td align="left"><code>int <b>EXIT_SUCCESS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro can be used with the <code>exit</code> function to indicate
 successful program completion.
 
@@ -65499,16 +64100,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EXIT_FAILURE</b><i>
-</i></td>
+<td align="left"><code>int <b>EXIT_FAILURE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro can be used with the <code>exit</code> function to indicate
 unsuccessful program completion in a general sense.
 
@@ -65528,12 +64128,12 @@
 termination (i.e. <code>exit</code>), though, the program's exit status becomes
 part of the process' termination status.
 
 <p><hr>
-Node:<a name="Cleanups%20on%20Exit">Cleanups on Exit</a>,
-Next:<a rel=next accesskey=n href="#Aborting%20a%20Program">Aborting a Program</a>,
-Previous:<a rel=previous accesskey=p href="#Exit%20Status">Exit Status</a>,
-Up:<a rel=up accesskey=u href="#Program%20Termination">Program Termination</a>
+Node:<a name="Cleanups on Exit">Cleanups on Exit</a>,
+Next:<a rel=next accesskey=n href="#Aborting a Program">Aborting a Program</a>,
+Previous:<a rel=previous accesskey=p href="#Exit Status">Exit Status</a>,
+Up:<a rel=up accesskey=u href="#Program Termination">Program Termination</a>
 <br>
 
 <h4>Cleanups on Exit</h4>
 
@@ -65545,16 +64145,15 @@
 application, by setting up a cleanup function in the library itself
 using <code>atexit</code> or <code>on_exit</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>atexit</b><i> (void (*<var>function</var>) (void))
-</i></td>
+<td align="left"><code>int <b>atexit</b><i> (void (*<var>function</var>) (void))</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>atexit</code> function registers the function <var>function</var> to be
 called at normal program termination.  The <var>function</var> is called with
 no arguments.
@@ -65564,16 +64163,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>on_exit</b><i> (void (*<var>function</var>)(int <var>status</var>, void *<var>arg</var>), void *<var>arg</var>)
-</i></td>
+<td align="left"><code>int <b>on_exit</b><i> (void (*<var>function</var>)(int <var>status</var>, void *<var>arg</var>), void *<var>arg</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is a somewhat more powerful variant of <code>atexit</code>.  It
 accepts two arguments, a function <var>function</var> and an arbitrary
 pointer <var>arg</var>.  At normal program termination, the <var>function</var> is
@@ -65609,36 +64207,35 @@
 
 <p>When this program is executed, it just prints the message and exits.
 
 <p><hr>
-Node:<a name="Aborting%20a%20Program">Aborting a Program</a>,
-Next:<a rel=next accesskey=n href="#Termination%20Internals">Termination Internals</a>,
-Previous:<a rel=previous accesskey=p href="#Cleanups%20on%20Exit">Cleanups on Exit</a>,
-Up:<a rel=up accesskey=u href="#Program%20Termination">Program Termination</a>
+Node:<a name="Aborting a Program">Aborting a Program</a>,
+Next:<a rel=next accesskey=n href="#Termination Internals">Termination Internals</a>,
+Previous:<a rel=previous accesskey=p href="#Cleanups on Exit">Cleanups on Exit</a>,
+Up:<a rel=up accesskey=u href="#Program Termination">Program Termination</a>
 <br>
 
 <h4>Aborting a Program</h4>
 
 <p>You can abort your program using the <code>abort</code> function.  The prototype
 for this function is in <code>stdlib.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>abort</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>abort</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>abort</code> function causes abnormal program termination.  This
 does not execute cleanup functions registered with <code>atexit</code> or
 <code>on_exit</code>.
 
 <p>This function actually terminates the process by raising a
 <code>SIGABRT</code> signal, and your program can include a handler to
-intercept this signal; see <a href="#Signal%20Handling">Signal Handling</a>. 
+intercept this signal; see <a href="#Signal Handling">Signal Handling</a>. 
 </td></tr>
 </table>
 
 <p><strong>Future Change Warning:</strong> Proposed Federal censorship regulations
@@ -65646,27 +64243,26 @@
 calling this function.  We would be required to say that this is not an
 acceptable way of terminating a program.
 
 <p><hr>
-Node:<a name="Termination%20Internals">Termination Internals</a>,
-Previous:<a rel=previous accesskey=p href="#Aborting%20a%20Program">Aborting a Program</a>,
-Up:<a rel=up accesskey=u href="#Program%20Termination">Program Termination</a>
+Node:<a name="Termination Internals">Termination Internals</a>,
+Previous:<a rel=previous accesskey=p href="#Aborting a Program">Aborting a Program</a>,
+Up:<a rel=up accesskey=u href="#Program Termination">Program Termination</a>
 <br>
 
 <h4>Termination Internals</h4>
 
 <p>The <code>_exit</code> function is the primitive used for process termination
 by <code>exit</code>.  It is declared in the header file <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>_exit</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>void <b>_exit</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>_exit</code> function is the primitive for causing a process to
 terminate with status <var>status</var>.  Calling this function does not
 execute cleanup functions registered with <code>atexit</code> or
@@ -65674,16 +64270,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>_Exit</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>void <b>_Exit</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>_Exit</code> function is the ISO&nbsp;C equivalent to <code>_exit</code>. 
 The ISO&nbsp;C committee members were not sure whether the definitions of
 <code>_exit</code> and <code>_Exit</code> were compatible so they have not used the
@@ -65698,14 +64293,14 @@
 terminates, or as a result of a signal--the
 following things happen:
 
 <ul>
-<li>All open file descriptors in the process are closed.  See <a href="#Low-Level%20I%2fO">Low-Level I/O</a>. 
+<li>All open file descriptors in the process are closed.  See <a href="#Low-Level I%2fO">Low-Level I/O</a>. 
 Note that streams are not flushed automatically when the process
-terminates; see <a href="#I%2fO%20on%20Streams">I/O on Streams</a>.
+terminates; see <a href="#I%2fO on Streams">I/O on Streams</a>.
 
 <li>A process exit status is saved to be reported back to the parent process
-via <code>wait</code> or <code>waitpid</code>; see <a href="#Process%20Completion">Process Completion</a>.  If the
+via <code>wait</code> or <code>waitpid</code>; see <a href="#Process Completion">Process Completion</a>.  If the
 program exited, this status includes as its low-order 8 bits the program
 exit status.
 
 <li>Any child processes of the process being terminated are assigned a new
@@ -65716,20 +64311,20 @@
 
 <li>If the process is a session leader that has a controlling terminal, then
 a <code>SIGHUP</code> signal is sent to each process in the foreground job,
 and the controlling terminal is disassociated from that session. 
-See <a href="#Job%20Control">Job Control</a>.
+See <a href="#Job Control">Job Control</a>.
 
 <li>If termination of a process causes a process group to become orphaned,
 and any member of that process group is stopped, then a <code>SIGHUP</code>
 signal and a <code>SIGCONT</code> signal are sent to each process in the
-group.  See <a href="#Job%20Control">Job Control</a>. 
+group.  See <a href="#Job Control">Job Control</a>. 
 </ul>
 
 <p><hr>
 Node:<a name="Processes">Processes</a>,
-Next:<a rel=next accesskey=n href="#Job%20Control">Job Control</a>,
-Previous:<a rel=previous accesskey=p href="#Program%20Basics">Program Basics</a>,
+Next:<a rel=next accesskey=n href="#Job Control">Job Control</a>,
+Previous:<a rel=previous accesskey=p href="#Program Basics">Program Basics</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Processes</h2>
@@ -65757,23 +64352,23 @@
 need more control over the details of how this is done, you can use the
 primitive functions to do each step individually instead.
 
 <ul>
-<li><a accesskey=1 href="#Running%20a%20Command">Running a Command</a>:            The easy way to run another program. 
-<li><a accesskey=2 href="#Process%20Creation%20Concepts">Process Creation Concepts</a>:    An overview of the hard way to do it. 
-<li><a accesskey=3 href="#Process%20Identification">Process Identification</a>:       How to get the process ID of a process. 
-<li><a accesskey=4 href="#Creating%20a%20Process">Creating a Process</a>:           How to fork a child process. 
-<li><a accesskey=5 href="#Executing%20a%20File">Executing a File</a>:             How to make a process execute another program. 
-<li><a accesskey=6 href="#Process%20Completion">Process Completion</a>:           How to tell when a child process has completed. 
-<li><a accesskey=7 href="#Process%20Completion%20Status">Process Completion Status</a>:    How to interpret the status value
+<li><a accesskey=1 href="#Running a Command">Running a Command</a>:            The easy way to run another program. 
+<li><a accesskey=2 href="#Process Creation Concepts">Process Creation Concepts</a>:    An overview of the hard way to do it. 
+<li><a accesskey=3 href="#Process Identification">Process Identification</a>:       How to get the process ID of a process. 
+<li><a accesskey=4 href="#Creating a Process">Creating a Process</a>:           How to fork a child process. 
+<li><a accesskey=5 href="#Executing a File">Executing a File</a>:             How to make a process execute another program. 
+<li><a accesskey=6 href="#Process Completion">Process Completion</a>:           How to tell when a child process has completed. 
+<li><a accesskey=7 href="#Process Completion Status">Process Completion Status</a>:    How to interpret the status value
                                  returned from a child process. 
-<li><a accesskey=8 href="#BSD%20Wait%20Functions">BSD Wait Functions</a>:   	More functions, for backward compatibility. 
-<li><a accesskey=9 href="#Process%20Creation%20Example">Process Creation Example</a>:     A complete example program. 
+<li><a accesskey=8 href="#BSD Wait Functions">BSD Wait Functions</a>:   	More functions, for backward compatibility. 
+<li><a accesskey=9 href="#Process Creation Example">Process Creation Example</a>:     A complete example program. 
 </ul>
 
 <p><hr>
-Node:<a name="Running%20a%20Command">Running a Command</a>,
-Next:<a rel=next accesskey=n href="#Process%20Creation%20Concepts">Process Creation Concepts</a>,
+Node:<a name="Running a Command">Running a Command</a>,
+Next:<a rel=next accesskey=n href="#Process Creation Concepts">Process Creation Concepts</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Running a Command</h3>
@@ -65783,23 +64378,22 @@
 it doesn't give you much control over the details: you have to wait
 until the subprogram terminates before you can do anything else.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>system</b><i> (const char *<var>command</var>)
-</i></td>
+<td align="left"><code>int <b>system</b><i> (const char *<var>command</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function executes <var>command</var> as a shell command.  In the GNU C
 library, it always uses the default shell <code>sh</code> to run the command. 
 In particular, it searches the directories in <code>PATH</code> to find
 programs to execute.  The return value is <code>-1</code> if it wasn't
 possible to create the shell process, and otherwise is the status of the
-shell process.  See <a href="#Process%20Completion">Process Completion</a>, for details on how this
+shell process.  See <a href="#Process Completion">Process Completion</a>, for details on how this
 status code can be interpreted.
 
 <p>If the <var>command</var> argument is a null pointer, a return value of zero
 indicates that no command processor is available.
@@ -65821,16 +64415,16 @@
 determine whether a command processor exists by executing
 <code>system&nbsp;(NULL)</code>; if the return value is nonzero, a command
 processor is available.
 
-<p>The <code>popen</code> and <code>pclose</code> functions (see <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>) are closely related to the <code>system</code> function.  They
+<p>The <code>popen</code> and <code>pclose</code> functions (see <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>) are closely related to the <code>system</code> function.  They
 allow the parent process to communicate with the standard input and
 output channels of the command being executed.
 
 <p><hr>
-Node:<a name="Process%20Creation%20Concepts">Process Creation Concepts</a>,
-Next:<a rel=next accesskey=n href="#Process%20Identification">Process Identification</a>,
-Previous:<a rel=previous accesskey=p href="#Running%20a%20Command">Running a Command</a>,
+Node:<a name="Process Creation Concepts">Process Creation Concepts</a>,
+Next:<a rel=next accesskey=n href="#Process Identification">Process Identification</a>,
+Previous:<a rel=previous accesskey=p href="#Running a Command">Running a Command</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Process Creation Concepts</h3>
@@ -65852,9 +64446,9 @@
 <p>After forking a child process, both the parent and child processes
 continue to execute normally.  If you want your program to wait for a
 child process to finish executing before continuing, you must do this
 explicitly after the fork operation, by calling <code>wait</code> or
-<code>waitpid</code> (see <a href="#Process%20Completion">Process Completion</a>).  These functions give you
+<code>waitpid</code> (see <a href="#Process Completion">Process Completion</a>).  These functions give you
 limited information about why the child terminated--for example, its
 exit status code.
 
 <p>A newly forked child process continues to execute the same program as
@@ -65863,18 +64457,18 @@
 is running in the parent process or the child.
 
 <p>Having several processes run the same program is only occasionally
 useful.  But the child can execute another program using one of the
-<code>exec</code> functions; see <a href="#Executing%20a%20File">Executing a File</a>.  The program that the
+<code>exec</code> functions; see <a href="#Executing a File">Executing a File</a>.  The program that the
 process is executing is called its <dfn>process image</dfn>.  Starting
 execution of a new program causes the process to forget all about its
 previous process image; when the new program exits, the process exits
 too, instead of returning to the previous process image.
 
 <p><hr>
-Node:<a name="Process%20Identification">Process Identification</a>,
-Next:<a rel=next accesskey=n href="#Creating%20a%20Process">Creating a Process</a>,
-Previous:<a rel=previous accesskey=p href="#Process%20Creation%20Concepts">Process Creation Concepts</a>,
+Node:<a name="Process Identification">Process Identification</a>,
+Next:<a rel=next accesskey=n href="#Creating a Process">Creating a Process</a>,
+Previous:<a rel=previous accesskey=p href="#Process Creation Concepts">Process Creation Concepts</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Process Identification</h3>
@@ -65886,55 +64480,52 @@
 program should include the header files <code>unistd.h</code> and
 <code>sys/types.h</code> to use these functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>pid_t</b><i>
-</i></td>
+<td align="left"><code><b>pid_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pid_t</code> data type is a signed integer type which is capable
 of representing a process ID.  In the GNU library, this is an <code>int</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>getpid</b><i> (void)
-</i></td>
+<td align="left"><code>pid_t <b>getpid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getpid</code> function returns the process ID of the current process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>getppid</b><i> (void)
-</i></td>
+<td align="left"><code>pid_t <b>getppid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getppid</code> function returns the process ID of the parent of the
 current process. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Creating%20a%20Process">Creating a Process</a>,
-Next:<a rel=next accesskey=n href="#Executing%20a%20File">Executing a File</a>,
-Previous:<a rel=previous accesskey=p href="#Process%20Identification">Process Identification</a>,
+Node:<a name="Creating a Process">Creating a Process</a>,
+Next:<a rel=next accesskey=n href="#Executing a File">Executing a File</a>,
+Previous:<a rel=previous accesskey=p href="#Process Identification">Process Identification</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Creating a Process</h3>
@@ -65942,16 +64533,15 @@
 <p>The <code>fork</code> function is the primitive for creating a process. 
 It is declared in the header file <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>fork</b><i> (void)
-</i></td>
+<td align="left"><code>pid_t <b>fork</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fork</code> function creates a new process.
 
 <p>If the operation is successful, there are then both parent and child
@@ -65967,9 +64557,9 @@
 <dt><code>EAGAIN</code>
 <dd>There aren't enough system resources to create another process, or the
 user already has too many processes running.  This means exceeding the
 <code>RLIMIT_NPROC</code> resource limit, which can usually be increased;
-see <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+see <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>ENOMEM</code>
 <dd>The process requires more space than the system can supply. 
 </dl>
@@ -65987,35 +64577,34 @@
 
 <li>The child process gets its own copies of the parent process's open file
 descriptors.  Subsequently changing attributes of the file descriptors
 in the parent process won't affect the file descriptors in the child,
-and vice versa.  See <a href="#Control%20Operations">Control Operations</a>.  However, the file position
+and vice versa.  See <a href="#Control Operations">Control Operations</a>.  However, the file position
 associated with each descriptor is shared by both processes;
-see <a href="#File%20Position">File Position</a>.
+see <a href="#File Position">File Position</a>.
 
 <li>The elapsed processor times for the child process are set to zero;
-see <a href="#Processor%20Time">Processor Time</a>.
+see <a href="#Processor Time">Processor Time</a>.
 
 <li>The child doesn't inherit file locks set by the parent process. 
-See <a href="#Control%20Operations">Control Operations</a>.
+See <a href="#Control Operations">Control Operations</a>.
 
 <li>The child doesn't inherit alarms set by the parent process. 
-See <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+See <a href="#Setting an Alarm">Setting an Alarm</a>.
 
-<li>The set of pending signals (see <a href="#Delivery%20of%20Signal">Delivery of Signal</a>) for the child
+<li>The set of pending signals (see <a href="#Delivery of Signal">Delivery of Signal</a>) for the child
 process is cleared.  (The child process inherits its mask of blocked
 signals and signal actions from the parent process.) 
 </ul>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>vfork</b><i> (void)
-</i></td>
+<td align="left"><code>pid_t <b>vfork</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>vfork</code> function is similar to <code>fork</code> but on some systems
 it is more efficient; however, there are restrictions you must follow to
 use it safely.
@@ -66042,11 +64631,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Executing%20a%20File">Executing a File</a>,
-Next:<a rel=next accesskey=n href="#Process%20Completion">Process Completion</a>,
-Previous:<a rel=previous accesskey=p href="#Creating%20a%20Process">Creating a Process</a>,
+Node:<a name="Executing a File">Executing a File</a>,
+Next:<a rel=next accesskey=n href="#Process Completion">Process Completion</a>,
+Previous:<a rel=previous accesskey=p href="#Creating a Process">Creating a Process</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Executing a File</h3>
@@ -66055,81 +64644,77 @@
 a file as a process image.  You can use these functions to make a child
 process execute a new program after it has been forked.
 
 <p>To see the effects of <code>exec</code> from the point of view of the called
-program, See <a href="#Program%20Basics">Program Basics</a>.
+program, See <a href="#Program Basics">Program Basics</a>.
 
 <p>The functions in this family differ in how you specify the arguments,
 but otherwise they all do the same thing.  They are declared in the
 header file <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>execv</b><i> (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>)
-</i></td>
+<td align="left"><code>int <b>execv</b><i> (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>execv</code> function executes the file named by <var>filename</var> as a
 new process image.
 
 <p>The <var>argv</var> argument is an array of null-terminated strings that is
 used to provide a value for the <code>argv</code> argument to the <code>main</code>
 function of the program to be executed.  The last element of this array
 must be a null pointer.  By convention, the first element of this array
-is the file name of the program sans directory names.  See <a href="#Program%20Arguments">Program Arguments</a>, for full details on how programs can access these arguments.
+is the file name of the program sans directory names.  See <a href="#Program Arguments">Program Arguments</a>, for full details on how programs can access these arguments.
 
 <p>The environment for the new process image is taken from the
 <code>environ</code> variable of the current process image; see
-<a href="#Environment%20Variables">Environment Variables</a>, for information about environments. 
+<a href="#Environment Variables">Environment Variables</a>, for information about environments. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>execl</b><i> (const char *<var>filename</var>, const char *<var>arg0</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>execl</b><i> (const char *<var>filename</var>, const char *<var>arg0</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>execv</code>, but the <var>argv</var> strings are
 specified individually instead of as an array.  A null pointer must be
 passed as the last such argument. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>execve</b><i> (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>, char *const <var>env</var><tt>[]</tt>)
-</i></td>
+<td align="left"><code>int <b>execve</b><i> (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>, char *const <var>env</var><tt>[]</tt>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>execv</code>, but permits you to specify the environment
 for the new program explicitly as the <var>env</var> argument.  This should
 be an array of strings in the same format as for the <code>environ</code>
-variable; see <a href="#Environment%20Access">Environment Access</a>. 
+variable; see <a href="#Environment Access">Environment Access</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>execle</b><i> (const char *<var>filename</var>, const char *<var>arg0</var>, char *const <var>env</var><tt>[]</tt>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>execle</b><i> (const char *<var>filename</var>, const char *<var>arg0</var>, char *const <var>env</var><tt>[]</tt>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is similar to <code>execl</code>, but permits you to specify the
 environment for the new program explicitly.  The environment argument is
 passed following the null pointer that marks the last <var>argv</var>
@@ -66138,20 +64723,19 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>execvp</b><i> (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>)
-</i></td>
+<td align="left"><code>int <b>execvp</b><i> (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>execvp</code> function is similar to <code>execv</code>, except that it
 searches the directories listed in the <code>PATH</code> environment variable
-(see <a href="#Standard%20Environment">Standard Environment</a>) to find the full file name of a
+(see <a href="#Standard Environment">Standard Environment</a>) to find the full file name of a
 file from <var>filename</var> if <var>filename</var> does not contain a slash.
 
 <p>This function is useful for executing system utility programs, because
 it looks for them in the places that the user has chosen.  Shells use it
@@ -66159,24 +64743,23 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>execlp</b><i> (const char *<var>filename</var>, const char *<var>arg0</var>, <small>...</small>)
-</i></td>
+<td align="left"><code>int <b>execlp</b><i> (const char *<var>filename</var>, const char *<var>arg0</var>, <small>...</small>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is like <code>execl</code>, except that it performs the same
 file name searching as the <code>execvp</code> function. 
 </td></tr>
 </table>
 
 <p>The size of the argument list and environment list taken together must
-not be greater than <code>ARG_MAX</code> bytes.  See <a href="#General%20Limits">General Limits</a>.  In
+not be greater than <code>ARG_MAX</code> bytes.  See <a href="#General Limits">General Limits</a>.  In
 the GNU system, the size (which compares against <code>ARG_MAX</code>)
 includes, for each string, the number of characters in the string, plus
 the size of a <code>char *</code>, plus one, rounded up to a multiple of the
 size of a <code>char *</code>.  Other systems may have somewhat different
@@ -66184,9 +64767,9 @@
 
 <p>These functions normally don't return, since execution of a new program
 causes the currently executing program to go away completely.  A value
 of <code>-1</code> is returned in the event of a failure.  In addition to the
-usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>), the following
+usual file name errors (see <a href="#File Name Errors">File Name Errors</a>), the following
 <code>errno</code> error conditions are defined for these functions:
 
 <dl>
 <dt><code>E2BIG</code>
@@ -66203,9 +64786,9 @@
 <dd>Executing the specified file requires more storage than is available. 
 </dl>
 
 <p>If execution of the new file succeeds, it updates the access time field
-of the file as if the file had been read.  See <a href="#File%20Times">File Times</a>, for more
+of the file as if the file had been read.  See <a href="#File Times">File Times</a>, for more
 details about access times of files.
 
 <p>The point at which the file is closed again is not specified, but
 is at some point before the process exits or before another process
@@ -66215,57 +64798,57 @@
 copying only the argument and environment strings to new locations.  But
 many other attributes of the process are unchanged:
 
 <ul>
-<li>The process ID and the parent process ID.  See <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>.
+<li>The process ID and the parent process ID.  See <a href="#Process Creation Concepts">Process Creation Concepts</a>.
 
-<li>Session and process group membership.  See <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>.
+<li>Session and process group membership.  See <a href="#Concepts of Job Control">Concepts of Job Control</a>.
 
-<li>Real user ID and group ID, and supplementary group IDs.  See <a href="#Process%20Persona">Process Persona</a>.
+<li>Real user ID and group ID, and supplementary group IDs.  See <a href="#Process Persona">Process Persona</a>.
 
-<li>Pending alarms.  See <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<li>Pending alarms.  See <a href="#Setting an Alarm">Setting an Alarm</a>.
 
-<li>Current working directory and root directory.  See <a href="#Working%20Directory">Working Directory</a>.  In the GNU system, the root directory is not copied when
+<li>Current working directory and root directory.  See <a href="#Working Directory">Working Directory</a>.  In the GNU system, the root directory is not copied when
 executing a setuid program; instead the system default root directory
 is used for the new program.
 
-<li>File mode creation mask.  See <a href="#Setting%20Permissions">Setting Permissions</a>.
+<li>File mode creation mask.  See <a href="#Setting Permissions">Setting Permissions</a>.
 
-<li>Process signal mask; see <a href="#Process%20Signal%20Mask">Process Signal Mask</a>.
+<li>Process signal mask; see <a href="#Process Signal Mask">Process Signal Mask</a>.
 
-<li>Pending signals; see <a href="#Blocking%20Signals">Blocking Signals</a>.
+<li>Pending signals; see <a href="#Blocking Signals">Blocking Signals</a>.
 
-<li>Elapsed processor time associated with the process; see <a href="#Processor%20Time">Processor Time</a>. 
+<li>Elapsed processor time associated with the process; see <a href="#Processor Time">Processor Time</a>. 
 </ul>
 
 <p>If the set-user-ID and set-group-ID mode bits of the process image file
 are set, this affects the effective user ID and effective group ID
 (respectively) of the process.  These concepts are discussed in detail
-in <a href="#Process%20Persona">Process Persona</a>.
+in <a href="#Process Persona">Process Persona</a>.
 
 <p>Signals that are set to be ignored in the existing process image are
 also set to be ignored in the new process image.  All other signals are
 set to the default action in the new process image.  For more
-information about signals, see <a href="#Signal%20Handling">Signal Handling</a>.
+information about signals, see <a href="#Signal Handling">Signal Handling</a>.
 
 <p>File descriptors open in the existing process image remain open in the
 new process image, unless they have the <code>FD_CLOEXEC</code>
 (close-on-exec) flag set.  The files that remain open inherit all
 attributes of the open file description from the existing process image,
-including file locks.  File descriptors are discussed in <a href="#Low-Level%20I%2fO">Low-Level I/O</a>.
+including file locks.  File descriptors are discussed in <a href="#Low-Level I%2fO">Low-Level I/O</a>.
 
 <p>Streams, by contrast, cannot survive through <code>exec</code> functions,
 because they are located in the memory of the process itself.  The new
 process image has no streams except those it creates afresh.  Each of
 the streams in the pre-<code>exec</code> process image has a descriptor inside
 it, and these descriptors do survive through <code>exec</code> (provided that
 they do not have <code>FD_CLOEXEC</code> set).  The new process image can
-reconnect these to new streams using <code>fdopen</code> (see <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>).
+reconnect these to new streams using <code>fdopen</code> (see <a href="#Descriptors and Streams">Descriptors and Streams</a>).
 
 <p><hr>
-Node:<a name="Process%20Completion">Process Completion</a>,
-Next:<a rel=next accesskey=n href="#Process%20Completion%20Status">Process Completion Status</a>,
-Previous:<a rel=previous accesskey=p href="#Executing%20a%20File">Executing a File</a>,
+Node:<a name="Process Completion">Process Completion</a>,
+Next:<a rel=next accesskey=n href="#Process Completion Status">Process Completion Status</a>,
+Previous:<a rel=previous accesskey=p href="#Executing a File">Executing a File</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Process Completion</h3>
@@ -66274,16 +64857,15 @@
 process to terminate or stop, and determine its status.  These functions
 are declared in the header file <code>sys/wait.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>waitpid</b><i> (pid_t <var>pid</var>, int *<var>status-ptr</var>, int <var>options</var>)
-</i></td>
+<td align="left"><code>pid_t <b>waitpid</b><i> (pid_t <var>pid</var>, int *<var>status-ptr</var>, int <var>options</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>waitpid</code> function is used to request status information from a
 child process whose process ID is <var>pid</var>.  Normally, the calling
 process is suspended until the child process makes status information
@@ -66337,9 +64919,9 @@
 
 <dl>
 <dt><code>EINTR</code>
 <dd>The function was interrupted by delivery of a signal to the calling
-process.  See <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+process.  See <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>ECHILD</code>
 <dd>There are no child processes to wait for, or the specified <var>pid</var>
 is not a child of the calling process.
@@ -66382,16 +64964,15 @@
 terminated. 
 </dl>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>wait</b><i> (int *<var>status-ptr</var>)
-</i></td>
+<td align="left"><code>pid_t <b>wait</b><i> (int *<var>status-ptr</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a simplified version of <code>waitpid</code>, and is used to wait
 until any one child process terminates.  The call:
 
@@ -66412,23 +64993,22 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>wait4</b><i> (pid_t <var>pid</var>, int *<var>status-ptr</var>, int <var>options</var>, struct rusage *<var>usage</var>)
-</i></td>
+<td align="left"><code>pid_t <b>wait4</b><i> (pid_t <var>pid</var>, int *<var>status-ptr</var>, int <var>options</var>, struct rusage *<var>usage</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>usage</var> is a null pointer, <code>wait4</code> is equivalent to
 <code>waitpid (<var>pid</var>, <var>status-ptr</var>, <var>options</var>)</code>.
 
 <p>If <var>usage</var> is not null, <code>wait4</code> stores usage figures for the
 child process in <code>*<var>rusage</var></code> (but only if the child has
-terminated, not if it has stopped).  See <a href="#Resource%20Usage">Resource Usage</a>.
+terminated, not if it has stopped).  See <a href="#Resource Usage">Resource Usage</a>.
 
 <p>This function is a BSD extension. 
 </td></tr>
 </table>
@@ -66459,132 +65039,125 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Process%20Completion%20Status">Process Completion Status</a>,
-Next:<a rel=next accesskey=n href="#BSD%20Wait%20Functions">BSD Wait Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Process%20Completion">Process Completion</a>,
+Node:<a name="Process Completion Status">Process Completion Status</a>,
+Next:<a rel=next accesskey=n href="#BSD Wait Functions">BSD Wait Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Process Completion">Process Completion</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Process Completion Status</h3>
 
-<p>If the exit status value (see <a href="#Program%20Termination">Program Termination</a>) of the child
+<p>If the exit status value (see <a href="#Program Termination">Program Termination</a>) of the child
 process is zero, then the status value reported by <code>waitpid</code> or
 <code>wait</code> is also zero.  You can test for other kinds of information
 encoded in the returned status value using the following macros. 
 These macros are defined in the header file <code>sys/wait.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WIFEXITED</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>int <b>WIFEXITED</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value if the child process terminated
 normally with <code>exit</code> or <code>_exit</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WEXITSTATUS</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>int <b>WEXITSTATUS</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <code>WIFEXITED</code> is true of <var>status</var>, this macro returns the
 low-order 8 bits of the exit status value from the child process. 
-See <a href="#Exit%20Status">Exit Status</a>. 
+See <a href="#Exit Status">Exit Status</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WIFSIGNALED</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>int <b>WIFSIGNALED</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value if the child process terminated
 because it received a signal that was not handled. 
-See <a href="#Signal%20Handling">Signal Handling</a>. 
+See <a href="#Signal Handling">Signal Handling</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WTERMSIG</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>int <b>WTERMSIG</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <code>WIFSIGNALED</code> is true of <var>status</var>, this macro returns the
 signal number of the signal that terminated the child process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WCOREDUMP</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>int <b>WCOREDUMP</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value if the child process terminated
 and produced a core dump. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WIFSTOPPED</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>int <b>WIFSTOPPED</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro returns a nonzero value if the child process is stopped. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>WSTOPSIG</b><i> (int <var>status</var>)
-</i></td>
+<td align="left"><code>int <b>WSTOPSIG</b><i> (int <var>status</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <code>WIFSTOPPED</code> is true of <var>status</var>, this macro returns the
 signal number of the signal that caused the child process to stop. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="BSD%20Wait%20Functions">BSD Wait Functions</a>,
-Next:<a rel=next accesskey=n href="#Process%20Creation%20Example">Process Creation Example</a>,
-Previous:<a rel=previous accesskey=p href="#Process%20Completion%20Status">Process Completion Status</a>,
+Node:<a name="BSD Wait Functions">BSD Wait Functions</a>,
+Next:<a rel=next accesskey=n href="#Process Creation Example">Process Creation Example</a>,
+Previous:<a rel=previous accesskey=p href="#Process Completion Status">Process Completion Status</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>BSD Process Wait Functions</h3>
@@ -66599,16 +65172,15 @@
 
 <p>These functions are declared in <code>sys/wait.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>union wait</b><i>
-</i></td>
+<td align="left"><code><b>union wait</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This data type represents program termination status values.  It has
 the following members:
 
@@ -66638,29 +65210,28 @@
 <p>The <code>wait3</code> function is the predecessor to <code>wait4</code>, which is
 more flexible.  <code>wait3</code> is now obsolete.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>wait3</b><i> (union wait *<var>status-ptr</var>, int <var>options</var>, struct rusage *<var>usage</var>)
-</i></td>
+<td align="left"><code>pid_t <b>wait3</b><i> (union wait *<var>status-ptr</var>, int <var>options</var>, struct rusage *<var>usage</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If <var>usage</var> is a null pointer, <code>wait3</code> is equivalent to
 <code>waitpid (-1, <var>status-ptr</var>, <var>options</var>)</code>.
 
 <p>If <var>usage</var> is not null, <code>wait3</code> stores usage figures for the
 child process in <code>*<var>rusage</var></code> (but only if the child has
-terminated, not if it has stopped).  See <a href="#Resource%20Usage">Resource Usage</a>. 
+terminated, not if it has stopped).  See <a href="#Resource Usage">Resource Usage</a>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Process%20Creation%20Example">Process Creation Example</a>,
-Previous:<a rel=previous accesskey=p href="#BSD%20Wait%20Functions">BSD Wait Functions</a>,
+Node:<a name="Process Creation Example">Process Creation Example</a>,
+Previous:<a rel=previous accesskey=p href="#BSD Wait Functions">BSD Wait Functions</a>,
 Up:<a rel=up accesskey=u href="#Processes">Processes</a>
 <br>
 
 <h3>Process Creation Example</h3>
@@ -66721,13 +65292,13 @@
 instead of <code>exit</code> is to avoid flushing fully buffered streams such
 as <code>stdout</code>.  The buffers of these streams probably contain data
 that was copied from the parent process by the <code>fork</code>, data that
 will be output eventually by the parent process.  Calling <code>exit</code> in
-the child would output the data twice.  See <a href="#Termination%20Internals">Termination Internals</a>.
+the child would output the data twice.  See <a href="#Termination Internals">Termination Internals</a>.
 
 <p><hr>
-Node:<a name="Job%20Control">Job Control</a>,
-Next:<a rel=next accesskey=n href="#Name%20Service%20Switch">Name Service Switch</a>,
+Node:<a name="Job Control">Job Control</a>,
+Next:<a rel=next accesskey=n href="#Name Service Switch">Name Service Switch</a>,
 Previous:<a rel=previous accesskey=p href="#Processes">Processes</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -66741,34 +65312,34 @@
 ignore the material in this chapter unless you are writing a shell or
 login program.
 
 <p>You need to be familiar with concepts relating to process creation
-(see <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>) and signal handling (see <a href="#Signal%20Handling">Signal Handling</a>) in order to understand this material presented in this
+(see <a href="#Process Creation Concepts">Process Creation Concepts</a>) and signal handling (see <a href="#Signal Handling">Signal Handling</a>) in order to understand this material presented in this
 chapter.
 
 <ul>
-<li><a accesskey=1 href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>:      Jobs can be controlled by a shell. 
-<li><a accesskey=2 href="#Job%20Control%20is%20Optional">Job Control is Optional</a>:      Not all POSIX systems support job control. 
-<li><a accesskey=3 href="#Controlling%20Terminal">Controlling Terminal</a>:         How a process gets its controlling terminal. 
-<li><a accesskey=4 href="#Access%20to%20the%20Terminal">Access to the Terminal</a>:       How processes share the controlling terminal. 
-<li><a accesskey=5 href="#Orphaned%20Process%20Groups">Orphaned Process Groups</a>:      Jobs left after the user logs out. 
-<li><a accesskey=6 href="#Implementing%20a%20Shell">Implementing a Shell</a>:         What a shell must do to implement job control. 
-<li><a accesskey=7 href="#Functions%20for%20Job%20Control">Functions for Job Control</a>:    Functions to control process groups. 
+<li><a accesskey=1 href="#Concepts of Job Control">Concepts of Job Control</a>:      Jobs can be controlled by a shell. 
+<li><a accesskey=2 href="#Job Control is Optional">Job Control is Optional</a>:      Not all POSIX systems support job control. 
+<li><a accesskey=3 href="#Controlling Terminal">Controlling Terminal</a>:         How a process gets its controlling terminal. 
+<li><a accesskey=4 href="#Access to the Terminal">Access to the Terminal</a>:       How processes share the controlling terminal. 
+<li><a accesskey=5 href="#Orphaned Process Groups">Orphaned Process Groups</a>:      Jobs left after the user logs out. 
+<li><a accesskey=6 href="#Implementing a Shell">Implementing a Shell</a>:         What a shell must do to implement job control. 
+<li><a accesskey=7 href="#Functions for Job Control">Functions for Job Control</a>:    Functions to control process groups. 
 </ul>
 
 <p><hr>
-Node:<a name="Concepts%20of%20Job%20Control">Concepts of Job Control</a>,
-Next:<a rel=next accesskey=n href="#Job%20Control%20is%20Optional">Job Control is Optional</a>,
-Up:<a rel=up accesskey=u href="#Job%20Control">Job Control</a>
+Node:<a name="Concepts of Job Control">Concepts of Job Control</a>,
+Next:<a rel=next accesskey=n href="#Job Control is Optional">Job Control is Optional</a>,
+Up:<a rel=up accesskey=u href="#Job Control">Job Control</a>
 <br>
 
 <h3>Concepts of Job Control</h3>
 
 <p>The fundamental purpose of an interactive shell is to read
 commands from the user's terminal and create processes to execute the
 programs specified by those commands.  It can do this using the
-<code>fork</code> (see <a href="#Creating%20a%20Process">Creating a Process</a>) and <code>exec</code>
-(see <a href="#Executing%20a%20File">Executing a File</a>) functions.
+<code>fork</code> (see <a href="#Creating a Process">Creating a Process</a>) and <code>exec</code>
+(see <a href="#Executing a File">Executing a File</a>) functions.
 
 <p>A single command may run just one process--but often one command uses
 several processes.  If you use the <code>|</code> operator in a shell command,
 you explicitly request several programs in their own processes.  But
@@ -66815,22 +65386,22 @@
 
 <p>If a background job needs to read from its controlling
 terminal, it is <dfn>stopped</dfn> by the terminal driver; if the
 <code>TOSTOP</code> mode is set, likewise for writing.  The user can stop
-a foreground job by typing the SUSP character (see <a href="#Special%20Characters">Special Characters</a>) and a program can stop any job by sending it a
+a foreground job by typing the SUSP character (see <a href="#Special Characters">Special Characters</a>) and a program can stop any job by sending it a
 <code>SIGSTOP</code> signal.  It's the responsibility of the shell to notice
 when jobs stop, to notify the user about them, and to provide mechanisms
 for allowing the user to interactively continue stopped jobs and switch
 jobs between foreground and background.
 
-<p>See <a href="#Access%20to%20the%20Terminal">Access to the Terminal</a>, for more information about I/O to the
+<p>See <a href="#Access to the Terminal">Access to the Terminal</a>, for more information about I/O to the
 controlling terminal,
 
 <p><hr>
-Node:<a name="Job%20Control%20is%20Optional">Job Control is Optional</a>,
-Next:<a rel=next accesskey=n href="#Controlling%20Terminal">Controlling Terminal</a>,
-Previous:<a rel=previous accesskey=p href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>,
-Up:<a rel=up accesskey=u href="#Job%20Control">Job Control</a>
+Node:<a name="Job Control is Optional">Job Control is Optional</a>,
+Next:<a rel=next accesskey=n href="#Controlling Terminal">Controlling Terminal</a>,
+Previous:<a rel=previous accesskey=p href="#Concepts of Job Control">Concepts of Job Control</a>,
+Up:<a rel=up accesskey=u href="#Job Control">Job Control</a>
 <br>
 
 <h3>Job Control is Optional</h3>
 
@@ -66838,25 +65409,25 @@
 support job control, but if you are using the GNU library on some other
 system, that system may not support job control itself.
 
 <p>You can use the <code>_POSIX_JOB_CONTROL</code> macro to test at compile-time
-whether the system supports job control.  See <a href="#System%20Options">System Options</a>.
+whether the system supports job control.  See <a href="#System Options">System Options</a>.
 
 <p>If job control is not supported, then there can be only one process
 group per session, which behaves as if it were always in the foreground. 
 The functions for creating additional process groups simply fail with
 the error code <code>ENOSYS</code>.
 
-<p>The macros naming the various job control signals (see <a href="#Job%20Control%20Signals">Job Control Signals</a>) are defined even if job control is not supported.  However,
+<p>The macros naming the various job control signals (see <a href="#Job Control Signals">Job Control Signals</a>) are defined even if job control is not supported.  However,
 the system never generates these signals, and attempts to send a job
 control signal or examine or specify their actions report errors or do
 nothing.
 
 <p><hr>
-Node:<a name="Controlling%20Terminal">Controlling Terminal</a>,
-Next:<a rel=next accesskey=n href="#Access%20to%20the%20Terminal">Access to the Terminal</a>,
-Previous:<a rel=previous accesskey=p href="#Job%20Control%20is%20Optional">Job Control is Optional</a>,
-Up:<a rel=up accesskey=u href="#Job%20Control">Job Control</a>
+Node:<a name="Controlling Terminal">Controlling Terminal</a>,
+Next:<a rel=next accesskey=n href="#Access to the Terminal">Access to the Terminal</a>,
+Previous:<a rel=previous accesskey=p href="#Job Control is Optional">Job Control is Optional</a>,
+Up:<a rel=up accesskey=u href="#Job Control">Job Control</a>
 <br>
 
 <h3>Controlling Terminal of a Process</h3>
 
@@ -66872,15 +65443,15 @@
 by the system when you log in.
 
 <p>An individual process disconnects from its controlling terminal when it
 calls <code>setsid</code> to become the leader of a new session. 
-See <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+See <a href="#Process Group Functions">Process Group Functions</a>.
 
 <p><hr>
-Node:<a name="Access%20to%20the%20Terminal">Access to the Terminal</a>,
-Next:<a rel=next accesskey=n href="#Orphaned%20Process%20Groups">Orphaned Process Groups</a>,
-Previous:<a rel=previous accesskey=p href="#Controlling%20Terminal">Controlling Terminal</a>,
-Up:<a rel=up accesskey=u href="#Job%20Control">Job Control</a>
+Node:<a name="Access to the Terminal">Access to the Terminal</a>,
+Next:<a rel=next accesskey=n href="#Orphaned Process Groups">Orphaned Process Groups</a>,
+Previous:<a rel=previous accesskey=p href="#Controlling Terminal">Controlling Terminal</a>,
+Up:<a rel=up accesskey=u href="#Job Control">Job Control</a>
 <br>
 
 <h3>Access to the Controlling Terminal</h3>
 
@@ -66898,9 +65469,9 @@
 
 <p>Similarly, when a process in a background job tries to write to its
 controlling terminal, the default behavior is to send a <code>SIGTTOU</code>
 signal to the process group.  However, the behavior is modified by the
-<code>TOSTOP</code> bit of the local modes flags (see <a href="#Local%20Modes">Local Modes</a>).  If
+<code>TOSTOP</code> bit of the local modes flags (see <a href="#Local Modes">Local Modes</a>).  If
 this bit is not set (which is the default), then writing to the
 controlling terminal is always permitted without sending a signal. 
 Writing is also permitted if the <code>SIGTTOU</code> signal is being ignored
 or blocked by the writing process.
@@ -66909,15 +65480,15 @@
 reading or as writing.  (The description of each operation should say
 which.)
 
 <p>For more information about the primitive <code>read</code> and <code>write</code>
-functions, see <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+functions, see <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <p><hr>
-Node:<a name="Orphaned%20Process%20Groups">Orphaned Process Groups</a>,
-Next:<a rel=next accesskey=n href="#Implementing%20a%20Shell">Implementing a Shell</a>,
-Previous:<a rel=previous accesskey=p href="#Access%20to%20the%20Terminal">Access to the Terminal</a>,
-Up:<a rel=up accesskey=u href="#Job%20Control">Job Control</a>
+Node:<a name="Orphaned Process Groups">Orphaned Process Groups</a>,
+Next:<a rel=next accesskey=n href="#Implementing a Shell">Implementing a Shell</a>,
+Previous:<a rel=previous accesskey=p href="#Access to the Terminal">Access to the Terminal</a>,
+Up:<a rel=up accesskey=u href="#Job Control">Job Control</a>
 <br>
 
 <h3>Orphaned Process Groups</h3>
 
@@ -66932,17 +65503,17 @@
 
 <p>When a process group becomes an orphan, its processes are sent a
 <code>SIGHUP</code> signal.  Ordinarily, this causes the processes to
 terminate.  However, if a program ignores this signal or establishes a
-handler for it (see <a href="#Signal%20Handling">Signal Handling</a>), it can continue running as in
+handler for it (see <a href="#Signal Handling">Signal Handling</a>), it can continue running as in
 the orphan process group even after its controlling process terminates;
 but it still cannot access the terminal any more.
 
 <p><hr>
-Node:<a name="Implementing%20a%20Shell">Implementing a Shell</a>,
-Next:<a rel=next accesskey=n href="#Functions%20for%20Job%20Control">Functions for Job Control</a>,
-Previous:<a rel=previous accesskey=p href="#Orphaned%20Process%20Groups">Orphaned Process Groups</a>,
-Up:<a rel=up accesskey=u href="#Job%20Control">Job Control</a>
+Node:<a name="Implementing a Shell">Implementing a Shell</a>,
+Next:<a rel=next accesskey=n href="#Functions for Job Control">Functions for Job Control</a>,
+Previous:<a rel=previous accesskey=p href="#Orphaned Process Groups">Orphaned Process Groups</a>,
+Up:<a rel=up accesskey=u href="#Job Control">Job Control</a>
 <br>
 
 <h3>Implementing a Job Control Shell</h3>
 
@@ -66950,23 +65521,23 @@
 presenting an extensive sample program to illustrate the concepts
 involved.
 
 <ul>
-<li><a accesskey=1 href="#Data%20Structures">Data Structures</a>:              Introduction to the sample shell. 
-<li><a accesskey=2 href="#Initializing%20the%20Shell">Initializing the Shell</a>:       What the shell must do to take
+<li><a accesskey=1 href="#Data Structures">Data Structures</a>:              Introduction to the sample shell. 
+<li><a accesskey=2 href="#Initializing the Shell">Initializing the Shell</a>:       What the shell must do to take
 				 responsibility for job control. 
-<li><a accesskey=3 href="#Launching%20Jobs">Launching Jobs</a>:               Creating jobs to execute commands. 
-<li><a accesskey=4 href="#Foreground%20and%20Background">Foreground and Background</a>:    Putting a job in foreground of background. 
-<li><a accesskey=5 href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>:   Reporting job status. 
-<li><a accesskey=6 href="#Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>:      How to continue a stopped job in
+<li><a accesskey=3 href="#Launching Jobs">Launching Jobs</a>:               Creating jobs to execute commands. 
+<li><a accesskey=4 href="#Foreground and Background">Foreground and Background</a>:    Putting a job in foreground of background. 
+<li><a accesskey=5 href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>:   Reporting job status. 
+<li><a accesskey=6 href="#Continuing Stopped Jobs">Continuing Stopped Jobs</a>:      How to continue a stopped job in
 				 the foreground or background. 
-<li><a accesskey=7 href="#Missing%20Pieces">Missing Pieces</a>:               Other parts of the shell. 
+<li><a accesskey=7 href="#Missing Pieces">Missing Pieces</a>:               Other parts of the shell. 
 </ul>
 
 <p><hr>
-Node:<a name="Data%20Structures">Data Structures</a>,
-Next:<a rel=next accesskey=n href="#Initializing%20the%20Shell">Initializing the Shell</a>,
-Up:<a rel=up accesskey=u href="#Implementing%20a%20Shell">Implementing a Shell</a>
+Node:<a name="Data Structures">Data Structures</a>,
+Next:<a rel=next accesskey=n href="#Initializing the Shell">Initializing the Shell</a>,
+Up:<a rel=up accesskey=u href="#Implementing a Shell">Implementing a Shell</a>
 <br>
 
 <h4>Data Structures for the Shell</h4>
 
@@ -67047,12 +65618,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Initializing%20the%20Shell">Initializing the Shell</a>,
-Next:<a rel=next accesskey=n href="#Launching%20Jobs">Launching Jobs</a>,
-Previous:<a rel=previous accesskey=p href="#Data%20Structures">Data Structures</a>,
-Up:<a rel=up accesskey=u href="#Implementing%20a%20Shell">Implementing a Shell</a>
+Node:<a name="Initializing the Shell">Initializing the Shell</a>,
+Next:<a rel=next accesskey=n href="#Launching Jobs">Launching Jobs</a>,
+Previous:<a rel=previous accesskey=p href="#Data Structures">Data Structures</a>,
+Up:<a rel=up accesskey=u href="#Implementing a Shell">Implementing a Shell</a>
 <br>
 
 <h4>Initializing the Shell</h4>
 
@@ -67149,12 +65720,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Launching%20Jobs">Launching Jobs</a>,
-Next:<a rel=next accesskey=n href="#Foreground%20and%20Background">Foreground and Background</a>,
-Previous:<a rel=previous accesskey=p href="#Initializing%20the%20Shell">Initializing the Shell</a>,
-Up:<a rel=up accesskey=u href="#Implementing%20a%20Shell">Implementing a Shell</a>
+Node:<a name="Launching Jobs">Launching Jobs</a>,
+Next:<a rel=next accesskey=n href="#Foreground and Background">Foreground and Background</a>,
+Previous:<a rel=previous accesskey=p href="#Initializing the Shell">Initializing the Shell</a>,
+Up:<a rel=up accesskey=u href="#Implementing a Shell">Implementing a Shell</a>
 <br>
 
 <h4>Launching Jobs</h4>
 
@@ -67162,9 +65733,9 @@
 its controlling terminal, it can launch jobs in response to commands
 typed by the user.
 
 <p>To create the processes in a process group, you use the same <code>fork</code>
-and <code>exec</code> functions described in <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>. 
+and <code>exec</code> functions described in <a href="#Process Creation Concepts">Process Creation Concepts</a>. 
 Since there are multiple child processes involved, though, things are a
 little more complicated and you must be careful to do things in the
 right order.  Otherwise, nasty race conditions can result.
 
@@ -67175,9 +65746,9 @@
 in that group.  The sample shell program presented in this chapter uses
 the first approach because it makes bookkeeping somewhat simpler.
 
 <p>As each process is forked, it should put itself in the new process group
-by calling <code>setpgid</code>; see <a href="#Process%20Group%20Functions">Process Group Functions</a>.  The first
+by calling <code>setpgid</code>; see <a href="#Process Group Functions">Process Group Functions</a>.  The first
 process in the new group becomes its <dfn>process group leader</dfn>, and its
 process ID becomes the <dfn>process group ID</dfn> for the group.
 
 <p>The shell should also call <code>setpgid</code> to put each of its child
@@ -67197,9 +65768,9 @@
 <p>The next thing each child process should do is to reset its signal
 actions.
 
 <p>During initialization, the shell process set itself to ignore job
-control signals; see <a href="#Initializing%20the%20Shell">Initializing the Shell</a>.  As a result, any child
+control signals; see <a href="#Initializing the Shell">Initializing the Shell</a>.  As a result, any child
 processes it creates also ignore these signals by inheritance.  This is
 definitely undesirable, so each child process should explicitly set the
 actions for these signals back to <code>SIG_DFL</code> just after it is forked.
 
@@ -67209,13 +65780,13 @@
 of stop signals.  Applications that disable the normal interpretation of
 the SUSP character should provide some other mechanism for the user to
 stop the job.  When the user invokes this mechanism, the program should
 send a <code>SIGTSTP</code> signal to the process group of the process, not
-just to the process itself.  See <a href="#Signaling%20Another%20Process">Signaling Another Process</a>.
+just to the process itself.  See <a href="#Signaling Another Process">Signaling Another Process</a>.
 
 <p>Finally, each child process should call <code>exec</code> in the normal way. 
 This is also the point at which redirection of the standard input and
-output channels should be handled.  See <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>,
+output channels should be handled.  See <a href="#Duplicating Descriptors">Duplicating Descriptors</a>,
 for an explanation of how to do this.
 
 <p>Here is the function from the sample shell program that is responsible
 for launching a program.  The function is executed by each child process
@@ -67280,9 +65851,9 @@
 
 <p>Next, here is the function that actually launches a complete job. 
 After creating the child processes, this function calls some other
 functions to put the newly created job into the foreground or background;
-these are discussed in <a href="#Foreground%20and%20Background">Foreground and Background</a>.
+these are discussed in <a href="#Foreground and Background">Foreground and Background</a>.
 
 <br><pre>void
 launch_job (job *j, int foreground)
 {
@@ -67349,12 +65920,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Foreground%20and%20Background">Foreground and Background</a>,
-Next:<a rel=next accesskey=n href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>,
-Previous:<a rel=previous accesskey=p href="#Launching%20Jobs">Launching Jobs</a>,
-Up:<a rel=up accesskey=u href="#Implementing%20a%20Shell">Implementing a Shell</a>
+Node:<a name="Foreground and Background">Foreground and Background</a>,
+Next:<a rel=next accesskey=n href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>,
+Previous:<a rel=previous accesskey=p href="#Launching Jobs">Launching Jobs</a>,
+Up:<a rel=up accesskey=u href="#Implementing a Shell">Implementing a Shell</a>
 <br>
 
 <h4>Foreground and Background</h4>
 
@@ -67364,9 +65935,9 @@
 
 <p>When a foreground job is launched, the shell must first give it access
 to the controlling terminal by calling <code>tcsetpgrp</code>.  Then, the
 shell should wait for processes in that process group to terminate or
-stop.  This is discussed in more detail in <a href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>.
+stop.  This is discussed in more detail in <a href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>.
 
 <p>When all of the processes in the group have either completed or stopped,
 the shell should regain control of the terminal for its own process
 group by calling <code>tcsetpgrp</code> again.  Since stop signals caused by
@@ -67379,9 +65950,9 @@
 case the job is merely stopped, the shell should first save the current
 terminal modes so that it can restore them later if the job is
 continued.  The functions for dealing with terminal modes are
 <code>tcgetattr</code> and <code>tcsetattr</code>; these are described in
-<a href="#Terminal%20Modes">Terminal Modes</a>.
+<a href="#Terminal Modes">Terminal Modes</a>.
 
 <p>Here is the sample shell's function for doing all of this.
 
 <br><pre>/* Put job <var>j</var> in the foreground.  If <var>cont</var> is nonzero,
@@ -67434,19 +66005,19 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>,
-Next:<a rel=next accesskey=n href="#Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>,
-Previous:<a rel=previous accesskey=p href="#Foreground%20and%20Background">Foreground and Background</a>,
-Up:<a rel=up accesskey=u href="#Implementing%20a%20Shell">Implementing a Shell</a>
+Node:<a name="Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>,
+Next:<a rel=next accesskey=n href="#Continuing Stopped Jobs">Continuing Stopped Jobs</a>,
+Previous:<a rel=previous accesskey=p href="#Foreground and Background">Foreground and Background</a>,
+Up:<a rel=up accesskey=u href="#Implementing a Shell">Implementing a Shell</a>
 <br>
 
 <h4>Stopped and Terminated Jobs</h4>
 
 <p>When a foreground process is launched, the shell must block until all of
 the processes in that job have either terminated or stopped.  It can do
-this by calling the <code>waitpid</code> function; see <a href="#Process%20Completion">Process Completion</a>.  Use the <code>WUNTRACED</code> option so that status is reported
+this by calling the <code>waitpid</code> function; see <a href="#Process Completion">Process Completion</a>.  Use the <code>WUNTRACED</code> option so that status is reported
 for processes that stop as well as processes that terminate.
 
 <p>The shell must also check on the status of background jobs so that it
 can report terminated and stopped jobs to the user; this can be done by
@@ -67455,9 +66026,9 @@
 prompting for a new command.
 
 <p>The shell can also receive asynchronous notification that there is
 status information available for a child process by establishing a
-handler for <code>SIGCHLD</code> signals.  See <a href="#Signal%20Handling">Signal Handling</a>.
+handler for <code>SIGCHLD</code> signals.  See <a href="#Signal Handling">Signal Handling</a>.
 
 <p>In the sample shell program, the <code>SIGCHLD</code> signal is normally
 ignored.  This is to avoid reentrancy problems involving the global data
 structures the shell manipulates.  But at specific times when the shell
@@ -67592,12 +66163,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>,
-Next:<a rel=next accesskey=n href="#Missing%20Pieces">Missing Pieces</a>,
-Previous:<a rel=previous accesskey=p href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>,
-Up:<a rel=up accesskey=u href="#Implementing%20a%20Shell">Implementing a Shell</a>
+Node:<a name="Continuing Stopped Jobs">Continuing Stopped Jobs</a>,
+Next:<a rel=next accesskey=n href="#Missing Pieces">Missing Pieces</a>,
+Previous:<a rel=previous accesskey=p href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>,
+Up:<a rel=up accesskey=u href="#Implementing a Shell">Implementing a Shell</a>
 <br>
 
 <h4>Continuing Stopped Jobs</h4>
 
@@ -67610,9 +66181,9 @@
 
 <p>The sample shell program handles both newly created and continued jobs
 with the same pair of functions, <code>put_job_in_foreground</code> and
 <code>put_job_in_background</code>.  The definitions of these functions
-were given in <a href="#Foreground%20and%20Background">Foreground and Background</a>.  When continuing a
+were given in <a href="#Foreground and Background">Foreground and Background</a>.  When continuing a
 stopped job, a nonzero value is passed as the <var>cont</var> argument to
 ensure that the <code>SIGCONT</code> signal is sent and the terminal modes
 reset, as appropriate.
 
@@ -67644,11 +66215,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Missing%20Pieces">Missing Pieces</a>,
-Previous:<a rel=previous accesskey=p href="#Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>,
-Up:<a rel=up accesskey=u href="#Implementing%20a%20Shell">Implementing a Shell</a>
+Node:<a name="Missing Pieces">Missing Pieces</a>,
+Previous:<a rel=previous accesskey=p href="#Continuing Stopped Jobs">Continuing Stopped Jobs</a>,
+Up:<a rel=up accesskey=u href="#Implementing a Shell">Implementing a Shell</a>
 <br>
 
 <h4>The Missing Pieces</h4>
 
@@ -67667,48 +66238,48 @@
 <p>Here is a table summarizing the major entry points we have presented:
 
 <dl>
 <dt><code>void init_shell (void)</code>
-<dd>Initialize the shell's internal state.  See <a href="#Initializing%20the%20Shell">Initializing the Shell</a>.
+<dd>Initialize the shell's internal state.  See <a href="#Initializing the Shell">Initializing the Shell</a>.
 
 <br><dt><code>void launch_job (job *<var>j</var>, int <var>foreground</var>)</code>
 <dd>Launch the job <var>j</var> as either a foreground or background job. 
-See <a href="#Launching%20Jobs">Launching Jobs</a>.
+See <a href="#Launching Jobs">Launching Jobs</a>.
 
 <br><dt><code>void do_job_notification (void)</code>
 <dd>Check for and report any jobs that have terminated or stopped.  Can be
 called synchronously or within a handler for <code>SIGCHLD</code> signals. 
-See <a href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>.
+See <a href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>.
 
 <br><dt><code>void continue_job (job *<var>j</var>, int <var>foreground</var>)</code>
-<dd>Continue the job <var>j</var>.  See <a href="#Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>. 
+<dd>Continue the job <var>j</var>.  See <a href="#Continuing Stopped Jobs">Continuing Stopped Jobs</a>. 
 </dl>
 
 <p>Of course, a real shell would also want to provide other functions for
 managing jobs.  For example, it would be useful to have commands to list
 all active jobs or to send a signal (such as <code>SIGKILL</code>) to a job.
 
 <p><hr>
-Node:<a name="Functions%20for%20Job%20Control">Functions for Job Control</a>,
-Previous:<a rel=previous accesskey=p href="#Implementing%20a%20Shell">Implementing a Shell</a>,
-Up:<a rel=up accesskey=u href="#Job%20Control">Job Control</a>
+Node:<a name="Functions for Job Control">Functions for Job Control</a>,
+Previous:<a rel=previous accesskey=p href="#Implementing a Shell">Implementing a Shell</a>,
+Up:<a rel=up accesskey=u href="#Job Control">Job Control</a>
 <br>
 
 <h3>Functions for Job Control</h3>
 
 <p>This section contains detailed descriptions of the functions relating
 to job control.
 
 <ul>
-<li><a accesskey=1 href="#Identifying%20the%20Terminal">Identifying the Terminal</a>:     Determining the controlling terminal's name. 
-<li><a accesskey=2 href="#Process%20Group%20Functions">Process Group Functions</a>:      Functions for manipulating process groups. 
-<li><a accesskey=3 href="#Terminal%20Access%20Functions">Terminal Access Functions</a>:    Functions for controlling terminal access. 
+<li><a accesskey=1 href="#Identifying the Terminal">Identifying the Terminal</a>:     Determining the controlling terminal's name. 
+<li><a accesskey=2 href="#Process Group Functions">Process Group Functions</a>:      Functions for manipulating process groups. 
+<li><a accesskey=3 href="#Terminal Access Functions">Terminal Access Functions</a>:    Functions for controlling terminal access. 
 </ul>
 
 <p><hr>
-Node:<a name="Identifying%20the%20Terminal">Identifying the Terminal</a>,
-Next:<a rel=next accesskey=n href="#Process%20Group%20Functions">Process Group Functions</a>,
-Up:<a rel=up accesskey=u href="#Functions%20for%20Job%20Control">Functions for Job Control</a>
+Node:<a name="Identifying the Terminal">Identifying the Terminal</a>,
+Next:<a rel=next accesskey=n href="#Process Group Functions">Process Group Functions</a>,
+Up:<a rel=up accesskey=u href="#Functions for Job Control">Functions for Job Control</a>
 <br>
 
 <h4>Identifying the Controlling Terminal</h4>
 
@@ -67716,22 +66287,21 @@
 use to open the controlling terminal.  In the GNU library, it returns
 the same string all the time: <code>"/dev/tty"</code>.  That is a special
 "magic" file name that refers to the controlling terminal of the
 current process (if it has one).  To find the name of the specific
-terminal device, use <code>ttyname</code>; see <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>.
+terminal device, use <code>ttyname</code>; see <a href="#Is It a Terminal">Is It a Terminal</a>.
 
 <p>The function <code>ctermid</code> is declared in the header file
 <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>ctermid</b><i> (char *<var>string</var>)
-</i></td>
+<td align="left"><code>char * <b>ctermid</b><i> (char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>ctermid</code> function returns a string containing the file name of
 the controlling terminal for the current process.  If <var>string</var> is
 not a null pointer, it should be an array that can hold at least
@@ -67745,31 +66315,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>L_ctermid</b><i>
-</i></td>
+<td align="left"><code>int <b>L_ctermid</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that
 represents the size of a string large enough to hold the file name
 returned by <code>ctermid</code>. 
 </td></tr>
 </table>
 
 <p>See also the <code>isatty</code> and <code>ttyname</code> functions, in
-<a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>.
+<a href="#Is It a Terminal">Is It a Terminal</a>.
 
 <p><hr>
-Node:<a name="Process%20Group%20Functions">Process Group Functions</a>,
-Next:<a rel=next accesskey=n href="#Terminal%20Access%20Functions">Terminal Access Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Identifying%20the%20Terminal">Identifying the Terminal</a>,
-Up:<a rel=up accesskey=u href="#Functions%20for%20Job%20Control">Functions for Job Control</a>
+Node:<a name="Process Group Functions">Process Group Functions</a>,
+Next:<a rel=next accesskey=n href="#Terminal Access Functions">Terminal Access Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Identifying the Terminal">Identifying the Terminal</a>,
+Up:<a rel=up accesskey=u href="#Functions for Job Control">Functions for Job Control</a>
 <br>
 
 <h4>Process Group Functions</h4>
 
@@ -67777,16 +66346,15 @@
 Your program should include the header files <code>sys/types.h</code> and
 <code>unistd.h</code> to use these functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>setsid</b><i> (void)
-</i></td>
+<td align="left"><code>pid_t <b>setsid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>setsid</code> function creates a new session.  The calling process
 becomes the session leader, and is put in a new process group whose
 process group ID is the same as the process ID of that process.  There
@@ -67808,16 +66376,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>getsid</b><i> (pid_t <var>pid</var>)
-</i></td>
+<td align="left"><code>pid_t <b>getsid</b><i> (pid_t <var>pid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>getsid</code> function returns the process group ID of the session
 leader of the specified process.  If a <var>pid</var> is <code>0</code>, the
@@ -67840,56 +66407,53 @@
 </table>
 
 <p>The <code>getpgrp</code> function has two definitions: one derived from BSD
 Unix, and one from the POSIX.1 standard.  The feature test macros you
-have selected (see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>) determine which definition
+have selected (see <a href="#Feature Test Macros">Feature Test Macros</a>) determine which definition
 you get.  Specifically, you get the BSD version if you define
 <code>_BSD_SOURCE</code>; otherwise, you get the POSIX version if you define
 <code>_POSIX_SOURCE</code> or <code>_GNU_SOURCE</code>.  Programs written for old
 BSD systems will not include <code>unistd.h</code>, which defines
 <code>getpgrp</code> specially under <code>_BSD_SOURCE</code>.  You must link such
 programs with the <code>-lbsd-compat</code> option to get the BSD definition.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>getpgrp</b><i> (void)
-</i></td>
+<td align="left"><code>pid_t <b>getpgrp</b><i> (void)</i></code></td>
 <td align="right">POSIX.1 Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The POSIX.1 definition of <code>getpgrp</code> returns the process group ID of
 the calling process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>getpgrp</b><i> (pid_t <var>pid</var>)
-</i></td>
+<td align="left"><code>pid_t <b>getpgrp</b><i> (pid_t <var>pid</var>)</i></code></td>
 <td align="right">BSD Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The BSD definition of <code>getpgrp</code> returns the process group ID of the
 process <var>pid</var>.  You can supply a value of <code>0</code> for the <var>pid</var>
 argument to get information about the calling process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpgid</b><i> (pid_t <var>pid</var>)
-</i></td>
+<td align="left"><code>int <b>getpgid</b><i> (pid_t <var>pid</var>)</i></code></td>
 <td align="right">System V Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>getpgid</code> is the same as the BSD function <code>getpgrp</code>.  It
 returns the process group ID of the process <var>pid</var>.  You can supply a
@@ -67910,23 +66474,22 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setpgid</b><i> (pid_t <var>pid</var>, pid_t <var>pgid</var>)
-</i></td>
+<td align="left"><code>int <b>setpgid</b><i> (pid_t <var>pid</var>, pid_t <var>pgid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>setpgid</code> function puts the process <var>pid</var> into the process
 group <var>pgid</var>.  As a special case, either <var>pid</var> or <var>pgid</var> can
 be zero to indicate the process ID of the calling process.
 
 <p>This function fails on a system that does not support job control. 
-See <a href="#Job%20Control%20is%20Optional">Job Control is Optional</a>, for more information.
+See <a href="#Job Control is Optional">Job Control is Optional</a>, for more information.
 
 <p>If the operation is successful, <code>setpgid</code> returns zero.  Otherwise
 it returns <code>-1</code>.  The following <code>errno</code> error conditions are
 defined for this function:
@@ -67955,26 +66518,25 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setpgrp</b><i> (pid_t <var>pid</var>, pid_t <var>pgid</var>)
-</i></td>
+<td align="left"><code>int <b>setpgrp</b><i> (pid_t <var>pid</var>, pid_t <var>pgid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the BSD Unix name for <code>setpgid</code>.  Both functions do exactly
 the same thing. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Terminal%20Access%20Functions">Terminal Access Functions</a>,
-Previous:<a rel=previous accesskey=p href="#Process%20Group%20Functions">Process Group Functions</a>,
-Up:<a rel=up accesskey=u href="#Functions%20for%20Job%20Control">Functions for Job Control</a>
+Node:<a name="Terminal Access Functions">Terminal Access Functions</a>,
+Previous:<a rel=previous accesskey=p href="#Process Group Functions">Process Group Functions</a>,
+Up:<a rel=up accesskey=u href="#Functions for Job Control">Functions for Job Control</a>
 <br>
 
 <h4>Functions for Controlling Terminal Access</h4>
 
@@ -67987,16 +66549,15 @@
 the terminal device, the foreground job is associated with the terminal
 file itself and not a particular open file descriptor.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>tcgetpgrp</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>pid_t <b>tcgetpgrp</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the process group ID of the foreground process
 group associated with the terminal open on descriptor <var>filedes</var>.
 
@@ -68023,16 +66584,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>tcsetpgrp</b><i> (int <var>filedes</var>, pid_t <var>pgid</var>)
-</i></td>
+<td align="left"><code>int <b>tcsetpgrp</b><i> (int <var>filedes</var>, pid_t <var>pgid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to set a terminal's foreground process group ID. 
 The argument <var>filedes</var> is a descriptor which specifies the terminal;
 <var>pgid</var> specifies the process group.  The calling process must be a
@@ -68070,16 +66630,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">pid_t <b>tcgetsid</b><i> (int <var>fildes</var>)
-</i></td>
+<td align="left"><code>pid_t <b>tcgetsid</b><i> (int <var>fildes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to obtain the process group ID of the session
 for which the terminal specified by <var>fildes</var> is the controlling terminal. 
 If the call is successful the group ID is returned.  Otherwise the
@@ -68096,11 +66655,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Name%20Service%20Switch">Name Service Switch</a>,
-Next:<a rel=next accesskey=n href="#Users%20and%20Groups">Users and Groups</a>,
-Previous:<a rel=previous accesskey=p href="#Job%20Control">Job Control</a>,
+Node:<a name="Name Service Switch">Name Service Switch</a>,
+Next:<a rel=next accesskey=n href="#Users and Groups">Users and Groups</a>,
+Previous:<a rel=previous accesskey=p href="#Job Control">Job Control</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>System Databases and Name Service Switch</h2>
@@ -68122,19 +66681,19 @@
 so the internal interface is incompatible.  This also manifests in the
 file names we use as we will see later.
 
 <ul>
-<li><a accesskey=1 href="#NSS%20Basics">NSS Basics</a>:                   What is this NSS good for. 
-<li><a accesskey=2 href="#NSS%20Configuration%20File">NSS Configuration File</a>:       Configuring NSS. 
-<li><a accesskey=3 href="#NSS%20Module%20Internals">NSS Module Internals</a>:         How does it work internally. 
-<li><a accesskey=4 href="#Extending%20NSS">Extending NSS</a>:                What to do to add services or databases. 
+<li><a accesskey=1 href="#NSS Basics">NSS Basics</a>:                   What is this NSS good for. 
+<li><a accesskey=2 href="#NSS Configuration File">NSS Configuration File</a>:       Configuring NSS. 
+<li><a accesskey=3 href="#NSS Module Internals">NSS Module Internals</a>:         How does it work internally. 
+<li><a accesskey=4 href="#Extending NSS">Extending NSS</a>:                What to do to add services or databases. 
 </ul>
 
 <p><hr>
-Node:<a name="NSS%20Basics">NSS Basics</a>,
-Next:<a rel=next accesskey=n href="#NSS%20Configuration%20File">NSS Configuration File</a>,
-Previous:<a rel=previous accesskey=p href="#Name%20Service%20Switch">Name Service Switch</a>,
-Up:<a rel=up accesskey=u href="#Name%20Service%20Switch">Name Service Switch</a>
+Node:<a name="NSS Basics">NSS Basics</a>,
+Next:<a rel=next accesskey=n href="#NSS Configuration File">NSS Configuration File</a>,
+Previous:<a rel=previous accesskey=p href="#Name Service Switch">Name Service Switch</a>,
+Up:<a rel=up accesskey=u href="#Name Service Switch">Name Service Switch</a>
 <br>
 
 <h3>NSS Basics</h3>
 
@@ -68162,35 +66721,35 @@
 <dd>Mail aliases
 <br><dt><code>ethers</code>
 <dd>Ethernet numbers,
 <br><dt><code>group</code>
-<dd>Groups of users, see <a href="#Group%20Database">Group Database</a>. 
+<dd>Groups of users, see <a href="#Group Database">Group Database</a>. 
 <br><dt><code>hosts</code>
-<dd>Host names and numbers, see <a href="#Host%20Names">Host Names</a>. 
+<dd>Host names and numbers, see <a href="#Host Names">Host Names</a>. 
 <br><dt><code>netgroup</code>
-<dd>Network wide list of host and users, see <a href="#Netgroup%20Database">Netgroup Database</a>. 
+<dd>Network wide list of host and users, see <a href="#Netgroup Database">Netgroup Database</a>. 
 <br><dt><code>networks</code>
-<dd>Network names and numbers, see <a href="#Networks%20Database">Networks Database</a>. 
+<dd>Network names and numbers, see <a href="#Networks Database">Networks Database</a>. 
 <br><dt><code>protocols</code>
-<dd>Network protocols, see <a href="#Protocols%20Database">Protocols Database</a>. 
+<dd>Network protocols, see <a href="#Protocols Database">Protocols Database</a>. 
 <br><dt><code>passwd</code>
-<dd>User passwords, see <a href="#User%20Database">User Database</a>. 
+<dd>User passwords, see <a href="#User Database">User Database</a>. 
 <br><dt><code>rpc</code>
 <dd>Remote procedure call names and numbers,
 <br><dt><code>services</code>
-<dd>Network services, see <a href="#Services%20Database">Services Database</a>. 
+<dd>Network services, see <a href="#Services Database">Services Database</a>. 
 <br><dt><code>shadow</code>
 <dd>Shadow user passwords,
 </dl>
 
 <p>There will be some more added later (<code>automount</code>, <code>bootparams</code>,
 <code>netmasks</code>, and <code>publickey</code>).
 
 <p><hr>
-Node:<a name="NSS%20Configuration%20File">NSS Configuration File</a>,
-Next:<a rel=next accesskey=n href="#NSS%20Module%20Internals">NSS Module Internals</a>,
-Previous:<a rel=previous accesskey=p href="#NSS%20Basics">NSS Basics</a>,
-Up:<a rel=up accesskey=u href="#Name%20Service%20Switch">Name Service Switch</a>
+Node:<a name="NSS Configuration File">NSS Configuration File</a>,
+Next:<a rel=next accesskey=n href="#NSS Module Internals">NSS Module Internals</a>,
+Previous:<a rel=previous accesskey=p href="#NSS Basics">NSS Basics</a>,
+Up:<a rel=up accesskey=u href="#Name Service Switch">Name Service Switch</a>
 <br>
 
 <h3>The NSS Configuration File</h3>
 
@@ -68232,19 +66791,19 @@
 <li>the reaction on lookup result like <code>[NOTFOUND=return]</code>. 
 </ul>
 
 <ul>
-<li><a accesskey=1 href="#Services%20in%20the%20NSS%20configuration">Services in the NSS configuration</a>:   Service names in the NSS configuration. 
-<li><a accesskey=2 href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>:   React appropriately to the lookup result. 
-<li><a accesskey=3 href="#Notes%20on%20NSS%20Configuration%20File">Notes on NSS Configuration File</a>:   Things to take care about while
+<li><a accesskey=1 href="#Services in the NSS configuration">Services in the NSS configuration</a>:   Service names in the NSS configuration. 
+<li><a accesskey=2 href="#Actions in the NSS configuration">Actions in the NSS configuration</a>:   React appropriately to the lookup result. 
+<li><a accesskey=3 href="#Notes on NSS Configuration File">Notes on NSS Configuration File</a>:   Things to take care about while
                                      configuring NSS. 
 </ul>
 
 <p><hr>
-Node:<a name="Services%20in%20the%20NSS%20configuration">Services in the NSS configuration</a>,
-Next:<a rel=next accesskey=n href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>,
-Previous:<a rel=previous accesskey=p href="#NSS%20Configuration%20File">NSS Configuration File</a>,
-Up:<a rel=up accesskey=u href="#NSS%20Configuration%20File">NSS Configuration File</a>
+Node:<a name="Services in the NSS configuration">Services in the NSS configuration</a>,
+Next:<a rel=next accesskey=n href="#Actions in the NSS configuration">Actions in the NSS configuration</a>,
+Previous:<a rel=previous accesskey=p href="#NSS Configuration File">NSS Configuration File</a>,
+Up:<a rel=up accesskey=u href="#NSS Configuration File">NSS Configuration File</a>
 <br>
 
 <h4>Services in the NSS configuration File</h4>
 
@@ -68268,12 +66827,12 @@
 found automatically.  Only the names of all available services are
 important.
 
 <p><hr>
-Node:<a name="Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>,
-Next:<a rel=next accesskey=n href="#Notes%20on%20NSS%20Configuration%20File">Notes on NSS Configuration File</a>,
-Previous:<a rel=previous accesskey=p href="#Services%20in%20the%20NSS%20configuration">Services in the NSS configuration</a>,
-Up:<a rel=up accesskey=u href="#NSS%20Configuration%20File">NSS Configuration File</a>
+Node:<a name="Actions in the NSS configuration">Actions in the NSS configuration</a>,
+Next:<a rel=next accesskey=n href="#Notes on NSS Configuration File">Notes on NSS Configuration File</a>,
+Previous:<a rel=previous accesskey=p href="#Services in the NSS configuration">Services in the NSS configuration</a>,
+Up:<a rel=up accesskey=u href="#NSS Configuration File">NSS Configuration File</a>
 <br>
 
 <h4>Actions in the NSS configuration</h4>
 
@@ -68357,11 +66916,11 @@
 is not completely ready to work (while booting or shutdown or
 network problems).
 
 <p><hr>
-Node:<a name="Notes%20on%20NSS%20Configuration%20File">Notes on NSS Configuration File</a>,
-Previous:<a rel=previous accesskey=p href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>,
-Up:<a rel=up accesskey=u href="#NSS%20Configuration%20File">NSS Configuration File</a>
+Node:<a name="Notes on NSS Configuration File">Notes on NSS Configuration File</a>,
+Previous:<a rel=previous accesskey=p href="#Actions in the NSS configuration">Actions in the NSS configuration</a>,
+Up:<a rel=up accesskey=u href="#NSS Configuration File">NSS Configuration File</a>
 <br>
 
 <h4>Notes on the NSS Configuration File</h4>
 
@@ -68399,12 +66958,12 @@
 used.  So it is unavoidable to use service entries like <code>nis</code> etc. 
 But one should avoid slow services like this if possible.
 
 <p><hr>
-Node:<a name="NSS%20Module%20Internals">NSS Module Internals</a>,
-Next:<a rel=next accesskey=n href="#Extending%20NSS">Extending NSS</a>,
-Previous:<a rel=previous accesskey=p href="#NSS%20Configuration%20File">NSS Configuration File</a>,
-Up:<a rel=up accesskey=u href="#Name%20Service%20Switch">Name Service Switch</a>
+Node:<a name="NSS Module Internals">NSS Module Internals</a>,
+Next:<a rel=next accesskey=n href="#Extending NSS">Extending NSS</a>,
+Previous:<a rel=previous accesskey=p href="#NSS Configuration File">NSS Configuration File</a>,
+Up:<a rel=up accesskey=u href="#Name Service Switch">Name Service Switch</a>
 <br>
 
 <h3>NSS Module Internals</h3>
 
@@ -68413,19 +66972,19 @@
 jump table or the like.  How this is done is of no interest here; those
 interested in this topic should read about Dynamic Linking.
 
 <ul>
-<li><a accesskey=1 href="#NSS%20Module%20Names">NSS Module Names</a>:             Construction of the interface function of
+<li><a accesskey=1 href="#NSS Module Names">NSS Module Names</a>:             Construction of the interface function of
                                 the NSS modules. 
-<li><a accesskey=2 href="#NSS%20Modules%20Interface">NSS Modules Interface</a>:        Programming interface in the NSS module
+<li><a accesskey=2 href="#NSS Modules Interface">NSS Modules Interface</a>:        Programming interface in the NSS module
                                 functions. 
 </ul>
 
 <p><hr>
-Node:<a name="NSS%20Module%20Names">NSS Module Names</a>,
-Next:<a rel=next accesskey=n href="#NSS%20Modules%20Interface">NSS Modules Interface</a>,
-Previous:<a rel=previous accesskey=p href="#NSS%20Module%20Internals">NSS Module Internals</a>,
-Up:<a rel=up accesskey=u href="#NSS%20Module%20Internals">NSS Module Internals</a>
+Node:<a name="NSS Module Names">NSS Module Names</a>,
+Next:<a rel=next accesskey=n href="#NSS Modules Interface">NSS Modules Interface</a>,
+Previous:<a rel=previous accesskey=p href="#NSS Module Internals">NSS Module Internals</a>,
+Up:<a rel=up accesskey=u href="#NSS Module Internals">NSS Module Internals</a>
 <br>
 
 <h4>The Naming Scheme of the NSS Modules</h4>
 
@@ -68462,9 +67021,9 @@
 <p>I.e., the reentrant functions <em>can</em> have counterparts.  No service
 module is forced to have functions for all databases and all kinds to
 access them.  If a function is not available it is simply treated as if
 the function would return <code>unavail</code>
-(see <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>).
+(see <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>).
 
 <p>The file name <code>libnss_files.so.2</code> would be on a Solaris&nbsp;2
 system <code>nss_files.so.2</code>.  This is the difference mentioned above. 
 Sun's NSS modules are usable as modules which get indirectly loaded
@@ -68476,11 +67035,11 @@
 impossible like it is for Solaris.  Now you can see why the modules are
 still libraries.<a rel=footnote href="#fn-4"><sup>4</sup></a>
 
 <p><hr>
-Node:<a name="NSS%20Modules%20Interface">NSS Modules Interface</a>,
-Previous:<a rel=previous accesskey=p href="#NSS%20Module%20Names">NSS Module Names</a>,
-Up:<a rel=up accesskey=u href="#NSS%20Module%20Internals">NSS Module Internals</a>
+Node:<a name="NSS Modules Interface">NSS Modules Interface</a>,
+Previous:<a rel=previous accesskey=p href="#NSS Module Names">NSS Module Names</a>,
+Up:<a rel=up accesskey=u href="#NSS Module Internals">NSS Module Internals</a>
 <br>
 
 <h4>The Interface of the Function in NSS Modules</h4>
 
@@ -68572,9 +67131,9 @@
 signature of the module function:
 
 <ul>
 <li>the return value is <code>int</code>;
-<li>the name is as explained in see <a href="#NSS%20Module%20Names">NSS Module Names</a>;
+<li>the name is as explained in see <a href="#NSS Module Names">NSS Module Names</a>;
 <li>the first arguments are identical to the arguments of the non-reentrant
 function;
 <li>the next three arguments are:
 
@@ -68596,11 +67155,11 @@
 <p>This table is correct for all functions but the <code>set<small>...</small>ent</code>
 and <code>end<small>...</small>ent</code> functions.
 
 <p><hr>
-Node:<a name="Extending%20NSS">Extending NSS</a>,
-Previous:<a rel=previous accesskey=p href="#NSS%20Module%20Internals">NSS Module Internals</a>,
-Up:<a rel=up accesskey=u href="#Name%20Service%20Switch">Name Service Switch</a>
+Node:<a name="Extending NSS">Extending NSS</a>,
+Previous:<a rel=previous accesskey=p href="#NSS Module Internals">NSS Module Internals</a>,
+Up:<a rel=up accesskey=u href="#Name Service Switch">Name Service Switch</a>
 <br>
 
 <h3>Extending NSS</h3>
 
@@ -68616,18 +67175,18 @@
 databases s/he is interested in and leave the rest for later (or
 completely aside).
 
 <ul>
-<li><a accesskey=1 href="#Adding%20another%20Service%20to%20NSS">Adding another Service to NSS</a>:   What is to do to add a new service. 
-<li><a accesskey=2 href="#NSS%20Module%20Function%20Internals">NSS Module Function Internals</a>:   Guidelines for writing new NSS
+<li><a accesskey=1 href="#Adding another Service to NSS">Adding another Service to NSS</a>:   What is to do to add a new service. 
+<li><a accesskey=2 href="#NSS Module Function Internals">NSS Module Function Internals</a>:   Guidelines for writing new NSS
                                         service functions. 
 </ul>
 
 <p><hr>
-Node:<a name="Adding%20another%20Service%20to%20NSS">Adding another Service to NSS</a>,
-Next:<a rel=next accesskey=n href="#NSS%20Module%20Function%20Internals">NSS Module Function Internals</a>,
-Previous:<a rel=previous accesskey=p href="#Extending%20NSS">Extending NSS</a>,
-Up:<a rel=up accesskey=u href="#Extending%20NSS">Extending NSS</a>
+Node:<a name="Adding another Service to NSS">Adding another Service to NSS</a>,
+Next:<a rel=next accesskey=n href="#NSS Module Function Internals">NSS Module Function Internals</a>,
+Previous:<a rel=previous accesskey=p href="#Extending NSS">Extending NSS</a>,
+Up:<a rel=up accesskey=u href="#Extending NSS">Extending NSS</a>
 <br>
 
 <h4>Adding another Service to NSS</h4>
 
@@ -68651,9 +67210,9 @@
 
 <br><pre>gcc -shared -o libnss_NAME.so.2 -Wl,-soname,libnss_NAME.so.2 OBJECTS
 </pre>
 
-<a href="gcc.html#Link%20Options">Options for Linking</a>, to learn
+<a href="gcc.html#Link Options">Options for Linking</a>, to learn
 more about this command line.
 
 <p>To use the new module the library must be able to find it.  This can be
 achieved by using options for the dynamic linker so that it will search
@@ -68670,11 +67229,11 @@
 careful: this should only be done if it is clear the module does not
 cause any harm.  System administrators should be careful.
 
 <p><hr>
-Node:<a name="NSS%20Module%20Function%20Internals">NSS Module Function Internals</a>,
-Previous:<a rel=previous accesskey=p href="#Adding%20another%20Service%20to%20NSS">Adding another Service to NSS</a>,
-Up:<a rel=up accesskey=u href="#Extending%20NSS">Extending NSS</a>
+Node:<a name="NSS Module Function Internals">NSS Module Function Internals</a>,
+Previous:<a rel=previous accesskey=p href="#Adding another Service to NSS">Adding another Service to NSS</a>,
+Up:<a rel=up accesskey=u href="#Extending NSS">Extending NSS</a>
 <br>
 
 <h4>Internals of the NSS Module Functions</h4>
 
@@ -68695,13 +67254,13 @@
 services this function simply is a noop.
 
 <p>One special case for this function is that it takes an additional
 argument for some <var>database</var>s (i.e., the interface is
-<code>int set<var>db</var>ent (int)</code>).  <a href="#Host%20Names">Host Names</a>, which describes the
+<code>int set<var>db</var>ent (int)</code>).  <a href="#Host Names">Host Names</a>, which describes the
 <code>sethostent</code> function.
 
 <p>The return value should be <var>NSS_STATUS_SUCCESS</var> or according to the
-table above in case of an error (see <a href="#NSS%20Modules%20Interface">NSS Modules Interface</a>).
+table above in case of an error (see <a href="#NSS Modules Interface">NSS Modules Interface</a>).
 
 <br><dt><code>enum nss_status _nss_<var>database</var>_end<var>db</var>ent (void)</code>
 <dd>This function simply closes all files which are still open or removes
 buffer caches.  If there are no files or buffers to remove this is again
@@ -68767,16 +67326,16 @@
 <p>Again, this function takes an additional last argument for the
 <code>host</code> and <code>networks</code> database.
 
 <p>The return value should as always follow the rules given above
-(see <a href="#NSS%20Modules%20Interface">NSS Modules Interface</a>).
+(see <a href="#NSS Modules Interface">NSS Modules Interface</a>).
 
 </dl>
 
 <p><hr>
-Node:<a name="Users%20and%20Groups">Users and Groups</a>,
-Next:<a rel=next accesskey=n href="#System%20Management">System Management</a>,
-Previous:<a rel=previous accesskey=p href="#Name%20Service%20Switch">Name Service Switch</a>,
+Node:<a name="Users and Groups">Users and Groups</a>,
+Next:<a rel=next accesskey=n href="#System Management">System Management</a>,
+Previous:<a rel=previous accesskey=p href="#Name Service Switch">Name Service Switch</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Users and Groups</h2>
@@ -68803,70 +67362,70 @@
 database of all the defined groups.  There are library functions you
 can use to examine these databases.
 
 <ul>
-<li><a accesskey=1 href="#User%20and%20Group%20IDs">User and Group IDs</a>:           Each user has a unique numeric ID;
+<li><a accesskey=1 href="#User and Group IDs">User and Group IDs</a>:           Each user has a unique numeric ID;
 				 likewise for groups. 
-<li><a accesskey=2 href="#Process%20Persona">Process Persona</a>:              The user IDs and group IDs of a process. 
-<li><a accesskey=3 href="#Why%20Change%20Persona">Why Change Persona</a>:           Why a program might need to change
+<li><a accesskey=2 href="#Process Persona">Process Persona</a>:              The user IDs and group IDs of a process. 
+<li><a accesskey=3 href="#Why Change Persona">Why Change Persona</a>:           Why a program might need to change
 				 its user and/or group IDs. 
-<li><a accesskey=4 href="#How%20Change%20Persona">How Change Persona</a>:           Changing the user and group IDs. 
-<li><a accesskey=5 href="#Reading%20Persona">Reading Persona</a>:              How to examine the user and group IDs.
+<li><a accesskey=4 href="#How Change Persona">How Change Persona</a>:           Changing the user and group IDs. 
+<li><a accesskey=5 href="#Reading Persona">Reading Persona</a>:              How to examine the user and group IDs.
 
 <p>
-</p><li><a accesskey=6 href="#Setting%20User%20ID">Setting User ID</a>:              Functions for setting the user ID. 
-<li><a accesskey=7 href="#Setting%20Groups">Setting Groups</a>:               Functions for setting the group IDs.
+</p><li><a accesskey=6 href="#Setting User ID">Setting User ID</a>:              Functions for setting the user ID. 
+<li><a accesskey=7 href="#Setting Groups">Setting Groups</a>:               Functions for setting the group IDs.
 
 <p>
-</p><li><a accesskey=8 href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>:        Turning setuid access on and off. 
-<li><a accesskey=9 href="#Setuid%20Program%20Example">Setuid Program Example</a>:       The pertinent parts of one sample program. 
-<li><a href="#Tips%20for%20Setuid">Tips for Setuid</a>:              How to avoid granting unlimited access.
+</p><li><a accesskey=8 href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>:        Turning setuid access on and off. 
+<li><a accesskey=9 href="#Setuid Program Example">Setuid Program Example</a>:       The pertinent parts of one sample program. 
+<li><a href="#Tips for Setuid">Tips for Setuid</a>:              How to avoid granting unlimited access.
 
 <p>
-</p><li><a href="#Who%20Logged%20In">Who Logged In</a>:                Getting the name of the user who logged in,
+</p><li><a href="#Who Logged In">Who Logged In</a>:                Getting the name of the user who logged in,
 				 or of the real user ID of the current process.
 
 <p>
-</p><li><a href="#User%20Accounting%20Database">User Accounting Database</a>:     Keeping information about users and various
+</p><li><a href="#User Accounting Database">User Accounting Database</a>:     Keeping information about users and various
                                  actions in databases.
 
 <p>
-</p><li><a href="#User%20Database">User Database</a>:                Functions and data structures for
+</p><li><a href="#User Database">User Database</a>:                Functions and data structures for
                         	 accessing the user database. 
-<li><a href="#Group%20Database">Group Database</a>:               Functions and data structures for
+<li><a href="#Group Database">Group Database</a>:               Functions and data structures for
                         	 accessing the group database. 
-<li><a href="#Database%20Example">Database Example</a>:             Example program showing the use of database
+<li><a href="#Database Example">Database Example</a>:             Example program showing the use of database
 				 inquiry functions. 
-<li><a href="#Netgroup%20Database">Netgroup Database</a>:            Functions for accessing the netgroup database. 
+<li><a href="#Netgroup Database">Netgroup Database</a>:            Functions for accessing the netgroup database. 
 </ul>
 
 <p><hr>
-Node:<a name="User%20and%20Group%20IDs">User and Group IDs</a>,
-Next:<a rel=next accesskey=n href="#Process%20Persona">Process Persona</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="User and Group IDs">User and Group IDs</a>,
+Next:<a rel=next accesskey=n href="#Process Persona">Process Persona</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>User and Group IDs</h3>
 
 <p>Each user account on a computer system is identified by a <dfn>user
 name</dfn> (or <dfn>login name</dfn>) and <dfn>user ID</dfn>.  Normally, each user name
 has a unique user ID, but it is possible for several login names to have
 the same user ID.  The user names and corresponding user IDs are stored
-in a data base which you can access as described in <a href="#User%20Database">User Database</a>.
+in a data base which you can access as described in <a href="#User Database">User Database</a>.
 
 <p>Users are classified in <dfn>groups</dfn>.  Each user name belongs to one
 <dfn>default group</dfn> and may also belong to any number of
 <dfn>supplementary groups</dfn>. Users who are members of the same group can
 share resources (such as files) that are not accessible to users who are
 not a member of that group.  Each group has a <dfn>group name</dfn> and
-<dfn>group ID</dfn>.  See <a href="#Group%20Database">Group Database</a>, for how to find information
+<dfn>group ID</dfn>.  See <a href="#Group Database">Group Database</a>, for how to find information
 about a group ID or group name.
 
 <p><hr>
-Node:<a name="Process%20Persona">Process Persona</a>,
-Next:<a rel=next accesskey=n href="#Why%20Change%20Persona">Why Change Persona</a>,
-Previous:<a rel=previous accesskey=p href="#User%20and%20Group%20IDs">User and Group IDs</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Process Persona">Process Persona</a>,
+Next:<a rel=next accesskey=n href="#Why Change Persona">Why Change Persona</a>,
+Previous:<a rel=previous accesskey=p href="#User and Group IDs">User and Group IDs</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>The Persona of a Process</h3>
 
@@ -68887,27 +67446,27 @@
 control, so we do not consider them part of the persona.  But they are
 also important.
 
 <p>Both the real and effective user ID can be changed during the lifetime
-of a process.  See <a href="#Why%20Change%20Persona">Why Change Persona</a>.
+of a process.  See <a href="#Why Change Persona">Why Change Persona</a>.
 
 <p>For details on how a process's effective user ID and group IDs affect
-its permission to access files, see <a href="#Access%20Permission">Access Permission</a>.
+its permission to access files, see <a href="#Access Permission">Access Permission</a>.
 
 <p>The effective user ID of a process also controls permissions for sending
-signals using the <code>kill</code> function.  See <a href="#Signaling%20Another%20Process">Signaling Another Process</a>.
+signals using the <code>kill</code> function.  See <a href="#Signaling Another Process">Signaling Another Process</a>.
 
 <p>Finally, there are many operations which can only be performed by a
 process whose effective user ID is zero.  A process with this user ID is
 a <dfn>privileged process</dfn>.  Commonly the user name <code>root</code> is
 associated with user ID 0, but there may be other user names with this
 ID.
 
 <p><hr>
-Node:<a name="Why%20Change%20Persona">Why Change Persona</a>,
-Next:<a rel=next accesskey=n href="#How%20Change%20Persona">How Change Persona</a>,
-Previous:<a rel=previous accesskey=p href="#Process%20Persona">Process Persona</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Why Change Persona">Why Change Persona</a>,
+Next:<a rel=next accesskey=n href="#How Change Persona">How Change Persona</a>,
+Previous:<a rel=previous accesskey=p href="#Process Persona">Process Persona</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Why Change the Persona of a Process?</h3>
 
@@ -68940,12 +67499,12 @@
 user ID to be that for <code>games</code>.  In effect, the program must
 adopt the persona of <code>games</code> so it can write the scores file.
 
 <p><hr>
-Node:<a name="How%20Change%20Persona">How Change Persona</a>,
-Next:<a rel=next accesskey=n href="#Reading%20Persona">Reading Persona</a>,
-Previous:<a rel=previous accesskey=p href="#Why%20Change%20Persona">Why Change Persona</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="How Change Persona">How Change Persona</a>,
+Next:<a rel=next accesskey=n href="#Reading Persona">Reading Persona</a>,
+Previous:<a rel=previous accesskey=p href="#Why Change Persona">Why Change Persona</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>How an Application Can Change Persona</h3>
 
@@ -68957,9 +67516,9 @@
 <p>You can't arbitrarily set your user ID or group ID to anything you want;
 only privileged processes can do that.  Instead, the normal way for a
 program to change its persona is that it has been set up in advance to
 change to a particular user or group.  This is the function of the setuid
-and setgid bits of a file's access mode.  See <a href="#Permission%20Bits">Permission Bits</a>.
+and setgid bits of a file's access mode.  See <a href="#Permission Bits">Permission Bits</a>.
 
 <p>When the setuid bit of an executable file is on, executing that file
 gives the process a third user ID: the <dfn>file user ID</dfn>.  This ID is
 set to the owner ID of the file.  The system then changes the effective
@@ -68978,16 +67537,16 @@
 To determine if a system has this feature, you can test the compiler
 define <code>_POSIX_SAVED_IDS</code>.  (In the POSIX standard, file IDs are
 known as saved IDs.)
 
-<p>See <a href="#File%20Attributes">File Attributes</a>, for a more general discussion of file modes and
+<p>See <a href="#File Attributes">File Attributes</a>, for a more general discussion of file modes and
 accessibility.
 
 <p><hr>
-Node:<a name="Reading%20Persona">Reading Persona</a>,
-Next:<a rel=next accesskey=n href="#Setting%20User%20ID">Setting User ID</a>,
-Previous:<a rel=previous accesskey=p href="#How%20Change%20Persona">How Change Persona</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Reading Persona">Reading Persona</a>,
+Next:<a rel=next accesskey=n href="#Setting User ID">Setting User ID</a>,
+Previous:<a rel=previous accesskey=p href="#How Change Persona">How Change Persona</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Reading the Persona of a Process</h3>
 
@@ -68996,102 +67555,95 @@
 facilities, you must include the header files <code>sys/types.h</code> and
 <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>uid_t</b><i>
-</i></td>
+<td align="left"><code><b>uid_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an integer data type used to represent user IDs.  In the GNU
 library, this is an alias for <code>unsigned int</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>gid_t</b><i>
-</i></td>
+<td align="left"><code><b>gid_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an integer data type used to represent group IDs.  In the GNU
 library, this is an alias for <code>unsigned int</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uid_t <b>getuid</b><i> (void)
-</i></td>
+<td align="left"><code>uid_t <b>getuid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getuid</code> function returns the real user ID of the process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">gid_t <b>getgid</b><i> (void)
-</i></td>
+<td align="left"><code>gid_t <b>getgid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getgid</code> function returns the real group ID of the process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">uid_t <b>geteuid</b><i> (void)
-</i></td>
+<td align="left"><code>uid_t <b>geteuid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>geteuid</code> function returns the effective user ID of the process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">gid_t <b>getegid</b><i> (void)
-</i></td>
+<td align="left"><code>gid_t <b>getegid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getegid</code> function returns the effective group ID of the process. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getgroups</b><i> (int <var>count</var>, gid_t *<var>groups</var>)
-</i></td>
+<td align="left"><code>int <b>getgroups</b><i> (int <var>count</var>, gid_t *<var>groups</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getgroups</code> function is used to inquire about the supplementary
 group IDs of the process.  Up to <var>count</var> of these group IDs are
 stored in the array <var>groups</var>; the return value from the function is
@@ -69124,12 +67676,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Setting%20User%20ID">Setting User ID</a>,
-Next:<a rel=next accesskey=n href="#Setting%20Groups">Setting Groups</a>,
-Previous:<a rel=previous accesskey=p href="#Reading%20Persona">Reading Persona</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Setting User ID">Setting User ID</a>,
+Next:<a rel=next accesskey=n href="#Setting Groups">Setting Groups</a>,
+Previous:<a rel=previous accesskey=p href="#Reading Persona">Reading Persona</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Setting the User ID</h3>
 
@@ -69137,16 +67689,15 @@
 and/or effective) of a process.  To use these facilities, you must
 include the header files <code>sys/types.h</code> and <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>seteuid</b><i> (uid_t <var>neweuid</var>)
-</i></td>
+<td align="left"><code>int <b>seteuid</b><i> (uid_t <var>neweuid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the effective user ID of a process to <var>newuid</var>,
 provided that the process is allowed to change its effective user ID.  A
 privileged process (effective user ID zero) can change its effective
@@ -69172,16 +67723,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setuid</b><i> (uid_t <var>newuid</var>)
-</i></td>
+<td align="left"><code>int <b>setuid</b><i> (uid_t <var>newuid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If the calling process is privileged, this function sets both the real
 and effective user ID of the process to <var>newuid</var>.  It also deletes
 the file user ID of the process, if any.  <var>newuid</var> may be any
@@ -69196,16 +67746,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setreuid</b><i> (uid_t <var>ruid</var>, uid_t <var>euid</var>)
-</i></td>
+<td align="left"><code>int <b>setreuid</b><i> (uid_t <var>ruid</var>, uid_t <var>euid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the real user ID of the process to <var>ruid</var> and the
 effective user ID to <var>euid</var>.  If <var>ruid</var> is <code>-1</code>, it means
 not to change the real user ID; likewise if <var>euid</var> is <code>-1</code>, it
@@ -69214,9 +67763,9 @@
 <p>The <code>setreuid</code> function exists for compatibility with 4.3 BSD Unix,
 which does not support file IDs.  You can use this function to swap the
 effective and real user IDs of the process.  (Privileged processes are
 not limited to this particular usage.)  If file IDs are supported, you
-should use that feature instead of this function.  See <a href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>.
+should use that feature instead of this function.  See <a href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>.
 
 <p>The return value is <code>0</code> on success and <code>-1</code> on failure. 
 The following <code>errno</code> error conditions are defined for this
 function:
@@ -69229,12 +67778,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Setting%20Groups">Setting Groups</a>,
-Next:<a rel=next accesskey=n href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>,
-Previous:<a rel=previous accesskey=p href="#Setting%20User%20ID">Setting User ID</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Setting Groups">Setting Groups</a>,
+Next:<a rel=next accesskey=n href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>,
+Previous:<a rel=previous accesskey=p href="#Setting User ID">Setting User ID</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Setting the Group IDs</h3>
 
@@ -69242,16 +67791,15 @@
 and effective) of a process.  To use these facilities, you must include
 the header files <code>sys/types.h</code> and <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setegid</b><i> (gid_t <var>newgid</var>)
-</i></td>
+<td align="left"><code>int <b>setegid</b><i> (gid_t <var>newgid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the effective group ID of the process to
 <var>newgid</var>, provided that the process is allowed to change its group
 ID.  Just as with <code>seteuid</code>, if the process is privileged it may
@@ -69269,16 +67817,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setgid</b><i> (gid_t <var>newgid</var>)
-</i></td>
+<td align="left"><code>int <b>setgid</b><i> (gid_t <var>newgid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets both the real and effective group ID of the process
 to <var>newgid</var>, provided that the process is privileged.  It also
 deletes the file group ID, if any.
@@ -69291,16 +67838,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setregid</b><i> (gid_t <var>rgid</var>, gid_t <var>egid</var>)
-</i></td>
+<td align="left"><code>int <b>setregid</b><i> (gid_t <var>rgid</var>, gid_t <var>egid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the real group ID of the process to <var>rgid</var> and
 the effective group ID to <var>egid</var>.  If <var>rgid</var> is <code>-1</code>, it
 means not to change the real group ID; likewise if <var>egid</var> is
@@ -69310,9 +67856,9 @@
 Unix, which does not support file IDs.  You can use this function to
 swap the effective and real group IDs of the process.  (Privileged
 processes are not limited to this usage.)  If file IDs are supported,
 you should use that feature instead of using this function. 
-See <a href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>.
+See <a href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>.
 
 <p>The return values and error conditions for <code>setregid</code> are the same
 as those for <code>setreuid</code>. 
 </td></tr>
@@ -69334,16 +67880,15 @@
 group IDs.  To use <code>setgroups</code> or <code>initgroups</code>, your programs
 should include the header file <code>grp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setgroups</b><i> (size_t <var>count</var>, gid_t *<var>groups</var>)
-</i></td>
+<td align="left"><code>int <b>setgroups</b><i> (size_t <var>count</var>, gid_t *<var>groups</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function sets the process's supplementary group IDs.  It can only
 be called from privileged processes.  The <var>count</var> argument specifies
 the number of group IDs in the array <var>groups</var>.
@@ -69359,16 +67904,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>initgroups</b><i> (const char *<var>user</var>, gid_t <var>group</var>)
-</i></td>
+<td align="left"><code>int <b>initgroups</b><i> (const char *<var>user</var>, gid_t <var>group</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>initgroups</code> function sets the process's supplementary group
 IDs to be the normal default for the user name <var>user</var>.  The group
 <var>group</var> is automatically included.
@@ -69387,16 +67931,15 @@
 <code>getgrouplist</code>.  To use <code>getgrouplist</code>, your programs should
 include the header file <code>grp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getgrouplist</b><i> (const char *<var>user</var>, gid_t <var>group</var>, gid_t *<var>groups</var>, int *<var>ngroups</var>)
-</i></td>
+<td align="left"><code>int <b>getgrouplist</b><i> (const char *<var>user</var>, gid_t <var>group</var>, gid_t *<var>groups</var>, int *<var>ngroups</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getgrouplist</code> function scans the group database for all the
 groups <var>user</var> belongs to.  Up to *<var>ngroups</var> group IDs
 corresponding to these groups are stored in the array <var>groups</var>; the
@@ -69432,12 +67975,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>,
-Next:<a rel=next accesskey=n href="#Setuid%20Program%20Example">Setuid Program Example</a>,
-Previous:<a rel=previous accesskey=p href="#Setting%20Groups">Setting Groups</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Enable%2fDisable Setuid">Enable/Disable Setuid</a>,
+Next:<a rel=next accesskey=n href="#Setuid Program Example">Setuid Program Example</a>,
+Previous:<a rel=previous accesskey=p href="#Setting Groups">Setting Groups</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Enabling and Disabling Setuid Access</h3>
 
@@ -69496,12 +68039,12 @@
 #endif
 </pre>
 
 <p><hr>
-Node:<a name="Setuid%20Program%20Example">Setuid Program Example</a>,
-Next:<a rel=next accesskey=n href="#Tips%20for%20Setuid">Tips for Setuid</a>,
-Previous:<a rel=previous accesskey=p href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Setuid Program Example">Setuid Program Example</a>,
+Next:<a rel=next accesskey=n href="#Tips for Setuid">Tips for Setuid</a>,
+Previous:<a rel=previous accesskey=p href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Setuid Program Example</h3>
 
@@ -69633,12 +68176,12 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Tips%20for%20Setuid">Tips for Setuid</a>,
-Next:<a rel=next accesskey=n href="#Who%20Logged%20In">Who Logged In</a>,
-Previous:<a rel=previous accesskey=p href="#Setuid%20Program%20Example">Setuid Program Example</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Tips for Setuid">Tips for Setuid</a>,
+Next:<a rel=next accesskey=n href="#Who Logged In">Who Logged In</a>,
+Previous:<a rel=previous accesskey=p href="#Setuid Program Example">Setuid Program Example</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Tips for Writing Setuid Programs</h3>
 
@@ -69662,9 +68205,9 @@
 functions are a potential risk (since the program they execute depends
 on the user's <code>PATH</code> environment variable).
 
 <p>If you must <code>exec</code> another program under a changed ID, specify an
-absolute file name (see <a href="#File%20Name%20Resolution">File Name Resolution</a>) for the executable,
+absolute file name (see <a href="#File Name Resolution">File Name Resolution</a>) for the executable,
 and make sure that the protections on that executable and <em>all</em>
 containing directories are such that ordinary users cannot replace it
 with some other program.
 
@@ -69678,45 +68221,44 @@
 
 </p><li>Only use the user ID controlling the resource in the part of the program
 that actually uses that resource.  When you're finished with it, restore
 the effective user ID back to the actual user's user ID. 
-See <a href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>.
+See <a href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>.
 
 <li>If the <code>setuid</code> part of your program needs to access other files
 besides the controlled resource, it should verify that the real user
 would ordinarily have permission to access those files.  You can use the
-<code>access</code> function (see <a href="#Access%20Permission">Access Permission</a>) to check this; it
+<code>access</code> function (see <a href="#Access Permission">Access Permission</a>) to check this; it
 uses the real user and group IDs, rather than the effective IDs. 
 </ul>
 
 <p><hr>
-Node:<a name="Who%20Logged%20In">Who Logged In</a>,
-Next:<a rel=next accesskey=n href="#User%20Accounting%20Database">User Accounting Database</a>,
-Previous:<a rel=previous accesskey=p href="#Tips%20for%20Setuid">Tips for Setuid</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Who Logged In">Who Logged In</a>,
+Next:<a rel=next accesskey=n href="#User Accounting Database">User Accounting Database</a>,
+Previous:<a rel=previous accesskey=p href="#Tips for Setuid">Tips for Setuid</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Identifying Who Logged In</h3>
 
 <p>You can use the functions listed in this section to determine the login
 name of the user who is running a process, and the name of the user who
 logged in the current session.  See also the function <code>getuid</code> and
-friends (see <a href="#Reading%20Persona">Reading Persona</a>).  How this information is collected by
+friends (see <a href="#Reading Persona">Reading Persona</a>).  How this information is collected by
 the system and how to control/add/remove information from the background
-storage is described in <a href="#User%20Accounting%20Database">User Accounting Database</a>.
+storage is described in <a href="#User Accounting Database">User Accounting Database</a>.
 
 <p>The <code>getlogin</code> function is declared in <code>unistd.h</code>, while
 <code>cuserid</code> and <code>L_cuserid</code> are declared in <code>stdio.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>getlogin</b><i> (void)
-</i></td>
+<td align="left"><code>char * <b>getlogin</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getlogin</code> function returns a pointer to a string containing the
 name of the user logged in on the controlling terminal of the process,
 or a null pointer if this information cannot be determined.  The string
@@ -69725,16 +68267,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>cuserid</b><i> (char *<var>string</var>)
-</i></td>
+<td align="left"><code>char * <b>cuserid</b><i> (char *<var>string</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>cuserid</code> function returns a pointer to a string containing a
 user name associated with the effective ID of the process.  If
 <var>string</var> is not a null pointer, it should be an array that can hold
@@ -69749,37 +68290,36 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>L_cuserid</b><i>
-</i></td>
+<td align="left"><code>int <b>L_cuserid</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 An integer constant that indicates how long an array you might need to
 store a user name. 
 </td></tr>
 </table>
 
 <p>These functions let your program identify positively the user who is
 running or the user who logged in this session.  (These can differ when
-setuid programs are involved; see <a href="#Process%20Persona">Process Persona</a>.)  The user cannot
+setuid programs are involved; see <a href="#Process Persona">Process Persona</a>.)  The user cannot
 do anything to fool these functions.
 
 <p>For most purposes, it is more useful to use the environment variable
 <code>LOGNAME</code> to find out who the user is.  This is more flexible
 precisely because the user can set <code>LOGNAME</code> arbitrarily. 
-See <a href="#Standard%20Environment">Standard Environment</a>.
+See <a href="#Standard Environment">Standard Environment</a>.
 
 <p><hr>
-Node:<a name="User%20Accounting%20Database">User Accounting Database</a>,
-Next:<a rel=next accesskey=n href="#User%20Database">User Database</a>,
-Previous:<a rel=previous accesskey=p href="#Who%20Logged%20In">Who Logged In</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="User Accounting Database">User Accounting Database</a>,
+Next:<a rel=next accesskey=n href="#User Database">User Database</a>,
+Previous:<a rel=previous accesskey=p href="#Who Logged In">Who Logged In</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>The User Accounting Database</h3>
 
@@ -69796,35 +68336,34 @@
 from and writing information to the user accounting database, the
 functions described in this section should be used.
 
 <ul>
-<li><a accesskey=1 href="#Manipulating%20the%20Database">Manipulating the Database</a>:    Scanning and modifying the user
+<li><a accesskey=1 href="#Manipulating the Database">Manipulating the Database</a>:    Scanning and modifying the user
                                  accounting database. 
-<li><a accesskey=2 href="#XPG%20Functions">XPG Functions</a>:                A standardized way for doing the same thing. 
-<li><a accesskey=3 href="#Logging%20In%20and%20Out">Logging In and Out</a>:           Functions from BSD that modify the user
+<li><a accesskey=2 href="#XPG Functions">XPG Functions</a>:                A standardized way for doing the same thing. 
+<li><a accesskey=3 href="#Logging In and Out">Logging In and Out</a>:           Functions from BSD that modify the user
                                  accounting database. 
 </ul>
 
 <p><hr>
-Node:<a name="Manipulating%20the%20Database">Manipulating the Database</a>,
-Next:<a rel=next accesskey=n href="#XPG%20Functions">XPG Functions</a>,
-Up:<a rel=up accesskey=u href="#User%20Accounting%20Database">User Accounting Database</a>
+Node:<a name="Manipulating the Database">Manipulating the Database</a>,
+Next:<a rel=next accesskey=n href="#XPG Functions">XPG Functions</a>,
+Up:<a rel=up accesskey=u href="#User Accounting Database">User Accounting Database</a>
 <br>
 
 <h4>Manipulating the User Accounting Database</h4>
 
 <p>These functions and the corresponding data structures are declared in
 the header file <code>utmp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct exit_status</b><i>
-</i></td>
+<td align="left"><code><b>struct exit_status</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>exit_status</code> data structure is used to hold information about
 the exit status of processes marked as <code>DEAD_PROCESS</code> in the user
 accounting database.
@@ -69839,16 +68378,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct utmp</b><i>
-</i></td>
+<td align="left"><code><b>struct utmp</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>utmp</code> data structure is used to hold information about entries
 in the user accounting database.  On the GNU system it has the following
 members:
@@ -69947,16 +68485,15 @@
 compatibility only, <code>utmp.h</code> defines <code>ut_time</code> as an alias for
 <code>ut_tv.tv_sec</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setutent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>setutent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function opens the user accounting database to begin scanning it. 
 You can then call <code>getutent</code>, <code>getutid</code> or <code>getutline</code> to
 read entries and <code>pututline</code> to write entries.
@@ -69966,16 +68503,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmp * <b>getutent</b><i> (void)
-</i></td>
+<td align="left"><code>struct utmp * <b>getutent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getutent</code> function reads the next entry from the user
 accounting database.  It returns a pointer to the entry, which is
 statically allocated and may be overwritten by subsequent calls to
@@ -69987,30 +68523,28 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endutent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endutent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the user accounting database. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmp * <b>getutid</b><i> (const struct utmp *<var>id</var>)
-</i></td>
+<td align="left"><code>struct utmp * <b>getutid</b><i> (const struct utmp *<var>id</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function searches forward from the current point in the database
 for an entry that matches <var>id</var>.  If the <code>ut_type</code> member of the
 <var>id</var> structure is one of <code>RUN_LVL</code>, <code>BOOT_TIME</code>,
@@ -70039,16 +68573,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmp * <b>getutline</b><i> (const struct utmp *<var>line</var>)
-</i></td>
+<td align="left"><code>struct utmp * <b>getutline</b><i> (const struct utmp *<var>line</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function searches forward from the current point in the database
 until it finds an entry whose <code>ut_type</code> value is
 <code>LOGIN_PROCESS</code> or <code>USER_PROCESS</code>, and whose <code>ut_line</code>
@@ -70069,16 +68602,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmp * <b>pututline</b><i> (const struct utmp *<var>utmp</var>)
-</i></td>
+<td align="left"><code>struct utmp * <b>pututline</b><i> (const struct utmp *<var>utmp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pututline</code> function inserts the entry <code>*<var>utmp</var></code> at
 the appropriate place in the user accounting database.  If it finds that
 it is not already at the correct place in the database, it uses
@@ -70107,16 +68639,15 @@
 provides as extensions three more functions which return the data in a
 user-provided buffer.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getutent_r</b><i> (struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getutent_r</b><i> (struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getutent_r</code> is equivalent to the <code>getutent</code> function.  It
 returns the next entry from the database.  But instead of storing the
 information in a static buffer it stores it in the buffer pointed to by
@@ -70132,16 +68663,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getutid_r</b><i> (const struct utmp *<var>id</var>, struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getutid_r</b><i> (const struct utmp *<var>id</var>, struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function retrieves just like <code>getutid</code> the next entry matching
 the information stored in <var>id</var>.  But the result is stored in the
 buffer pointed to by the parameter <var>buffer</var>.
@@ -70155,16 +68685,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getutline_r</b><i> (const struct utmp *<var>line</var>, struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getutline_r</b><i> (const struct utmp *<var>line</var>, struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function retrieves just like <code>getutline</code> the next entry
 matching the information stored in <var>line</var>.  But the result is stored
 in the buffer pointed to by the parameter <var>buffer</var>.
@@ -70185,16 +68714,15 @@
 <p>For specifying which database to examine, the following function should
 be used.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>utmpname</b><i> (const char *<var>file</var>)
-</i></td>
+<td align="left"><code>int <b>utmpname</b><i> (const char *<var>file</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>utmpname</code> function changes the name of the database to be
 examined to <var>file</var>, and closes any previously opened database.  By
 default <code>getutent</code>, <code>getutid</code>, <code>getutline</code> and
@@ -70202,30 +68730,28 @@
 
 <p>The following macros are defined for use as the <var>file</var> argument:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>_PATH_UTMP</b><i>
-</i></td>
+<td align="left"><code>char * <b>_PATH_UTMP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used to specify the user accounting database. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>_PATH_WTMP</b><i>
-</i></td>
+<td align="left"><code>char * <b>_PATH_WTMP</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro is used to specify the user accounting log file. 
 </td></tr>
 </table>
@@ -70241,16 +68767,15 @@
 <p>Specially for maintaining log-like databases the GNU C Library provides
 the following function:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>updwtmp</b><i> (const char *<var>wtmp_file</var>, const struct utmp *<var>utmp</var>)
-</i></td>
+<td align="left"><code>void <b>updwtmp</b><i> (const char *<var>wtmp_file</var>, const struct utmp *<var>utmp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>updwtmp</code> function appends the entry *<var>utmp</var> to the
 database specified by <var>wtmp_file</var>.  For possible values for the
 <var>wtmp_file</var> argument see the <code>utmpname</code> function. 
@@ -70263,32 +68788,31 @@
 differences between the various definitions of <code>struct utmp</code>.  When
 programming for the GNU system, it is probably best to stick
 with the functions described in this section.  If however, you want your
 program to be portable, consider using the XPG functions described in
-<a href="#XPG%20Functions">XPG Functions</a>, or take a look at the BSD compatible functions in
-<a href="#Logging%20In%20and%20Out">Logging In and Out</a>.
+<a href="#XPG Functions">XPG Functions</a>, or take a look at the BSD compatible functions in
+<a href="#Logging In and Out">Logging In and Out</a>.
 
 <p><hr>
-Node:<a name="XPG%20Functions">XPG Functions</a>,
-Next:<a rel=next accesskey=n href="#Logging%20In%20and%20Out">Logging In and Out</a>,
-Previous:<a rel=previous accesskey=p href="#Manipulating%20the%20Database">Manipulating the Database</a>,
-Up:<a rel=up accesskey=u href="#User%20Accounting%20Database">User Accounting Database</a>
+Node:<a name="XPG Functions">XPG Functions</a>,
+Next:<a rel=next accesskey=n href="#Logging In and Out">Logging In and Out</a>,
+Previous:<a rel=previous accesskey=p href="#Manipulating the Database">Manipulating the Database</a>,
+Up:<a rel=up accesskey=u href="#User Accounting Database">User Accounting Database</a>
 <br>
 
 <h4>XPG User Accounting Database Functions</h4>
 
 <p>These functions, described in the X/Open Portability Guide, are declared
 in the header file <code>utmpx.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct utmpx</b><i>
-</i></td>
+<td align="left"><code><b>struct utmpx</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>utmpx</code> data structure contains at least the following members:
 
 <dl>
@@ -70358,94 +68882,88 @@
 <p>The size of the <code>ut_line</code>, <code>ut_id</code> and <code>ut_user</code> arrays
 can be found using the <code>sizeof</code> operator.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setutxent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>setutxent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>setutent</code>.  On the GNU system it is
 simply an alias for <code>setutent</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmpx * <b>getutxent</b><i> (void)
-</i></td>
+<td align="left"><code>struct utmpx * <b>getutxent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getutxent</code> function is similar to <code>getutent</code>, but returns
 a pointer to a <code>struct utmpx</code> instead of <code>struct utmp</code>.  On
 the GNU system it simply is an alias for <code>getutent</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endutxent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endutxent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>endutent</code>.  On the GNU system it is
 simply an alias for <code>endutent</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmpx * <b>getutxid</b><i> (const struct utmpx *<var>id</var>)
-</i></td>
+<td align="left"><code>struct utmpx * <b>getutxid</b><i> (const struct utmpx *<var>id</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getutid</code>, but uses <code>struct utmpx</code>
 instead of <code>struct utmp</code>.  On the GNU system it is simply an alias
 for <code>getutid</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmpx * <b>getutxline</b><i> (const struct utmpx *<var>line</var>)
-</i></td>
+<td align="left"><code>struct utmpx * <b>getutxline</b><i> (const struct utmpx *<var>line</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getutid</code>, but uses <code>struct utmpx</code>
 instead of <code>struct utmp</code>.  On the GNU system it is simply an alias
 for <code>getutline</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct utmpx * <b>pututxline</b><i> (const struct utmpx *<var>utmp</var>)
-</i></td>
+<td align="left"><code>struct utmpx * <b>pututxline</b><i> (const struct utmpx *<var>utmp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>pututxline</code> function is functionally identical to
 <code>pututline</code>, but uses <code>struct utmpx</code> instead of <code>struct
 utmp</code>.  On the GNU system, <code>pututxline</code> is simply an alias for
@@ -70453,16 +68971,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>utmpxname</b><i> (const char *<var>file</var>)
-</i></td>
+<td align="left"><code>int <b>utmpxname</b><i> (const char *<var>file</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>utmpxname</code> function is functionally identical to
 <code>utmpname</code>.  On the GNU system, <code>utmpxname</code> is simply an
 alias for <code>utmpname</code>. 
@@ -70474,41 +68991,39 @@
 these functions are merely copies, since the two structures are
 identical.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getutmp</b><i> (const struct utmpx *utmpx, struct utmp *utmp)
-</i></td>
+<td align="left"><code>int <b>getutmp</b><i> (const struct utmpx *utmpx, struct utmp *utmp)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>getutmp</code> copies the information, insofar as the structures are
 compatible, from <var>utmpx</var> to <var>utmp</var>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getutmpx</b><i> (const struct utmp *utmp, struct utmpx *utmpx)
-</i></td>
+<td align="left"><code>int <b>getutmpx</b><i> (const struct utmp *utmp, struct utmpx *utmpx)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 <code>getutmpx</code> copies the information, insofar as the structures are
 compatible, from <var>utmp</var> to <var>utmpx</var>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Logging%20In%20and%20Out">Logging In and Out</a>,
-Previous:<a rel=previous accesskey=p href="#XPG%20Functions">XPG Functions</a>,
-Up:<a rel=up accesskey=u href="#User%20Accounting%20Database">User Accounting Database</a>
+Node:<a name="Logging In and Out">Logging In and Out</a>,
+Previous:<a rel=previous accesskey=p href="#XPG Functions">XPG Functions</a>,
+Up:<a rel=up accesskey=u href="#User Accounting Database">User Accounting Database</a>
 <br>
 
 <h4>Logging In and Out</h4>
 
@@ -70519,16 +69034,15 @@
 <code>ut_name</code> in BSD.  Therefore, <code>ut_name</code> is defined as an alias
 for <code>ut_user</code> in <code>utmp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>login_tty</b><i> (int <var>filedes</var>)
-</i></td>
+<td align="left"><code>int <b>login_tty</b><i> (int <var>filedes</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function makes <var>filedes</var> the controlling terminal of the
 current process, redirects standard input, standard output and
 standard error output to this terminal, and closes <var>filedes</var>.
@@ -70538,16 +69052,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>login</b><i> (const struct utmp *<var>entry</var>)
-</i></td>
+<td align="left"><code>void <b>login</b><i> (const struct utmp *<var>entry</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>login</code> functions inserts an entry into the user accounting
 database.  The <code>ut_line</code> member is set to the name of the terminal
 on standard input.  If standard input is not a terminal <code>login</code>
@@ -70561,16 +69074,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>logout</b><i> (const char *<var>ut_line</var>)
-</i></td>
+<td align="left"><code>int <b>logout</b><i> (const char *<var>ut_line</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function modifies the user accounting database to indicate that the
 user on <var>ut_line</var> has logged out.
 
@@ -70579,16 +69091,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>logwtmp</b><i> (const char *<var>ut_line</var>, const char *<var>ut_name</var>, const char *<var>ut_host</var>)
-</i></td>
+<td align="left"><code>void <b>logwtmp</b><i> (const char *<var>ut_line</var>, const char *<var>ut_name</var>, const char *<var>ut_host</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>logwtmp</code> function appends an entry to the user accounting log
 file, for the current time and the information provided in the
 <var>ut_line</var>, <var>ut_name</var> and <var>ut_host</var> arguments. 
@@ -70599,12 +69110,12 @@
 <code>ut_line</code>, <code>ut_name</code>, <code>ut_host</code> and <code>ut_time</code>
 members.  Older systems do not even have the <code>ut_host</code> member.
 
 <p><hr>
-Node:<a name="User%20Database">User Database</a>,
-Next:<a rel=next accesskey=n href="#Group%20Database">Group Database</a>,
-Previous:<a rel=previous accesskey=p href="#User%20Accounting%20Database">User Accounting Database</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="User Database">User Database</a>,
+Next:<a rel=next accesskey=n href="#Group Database">Group Database</a>,
+Previous:<a rel=previous accesskey=p href="#User Accounting Database">User Accounting Database</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>User Database</h3>
 
@@ -70613,34 +69124,33 @@
 most systems, but on some systems a special network server gives access
 to it.
 
 <ul>
-<li><a accesskey=1 href="#User%20Data%20Structure">User Data Structure</a>:          What each user record contains. 
-<li><a accesskey=2 href="#Lookup%20User">Lookup User</a>:                  How to look for a particular user. 
-<li><a accesskey=3 href="#Scanning%20All%20Users">Scanning All Users</a>:           Scanning the list of all users, one by one. 
-<li><a accesskey=4 href="#Writing%20a%20User%20Entry">Writing a User Entry</a>:         How a program can rewrite a user's record. 
+<li><a accesskey=1 href="#User Data Structure">User Data Structure</a>:          What each user record contains. 
+<li><a accesskey=2 href="#Lookup User">Lookup User</a>:                  How to look for a particular user. 
+<li><a accesskey=3 href="#Scanning All Users">Scanning All Users</a>:           Scanning the list of all users, one by one. 
+<li><a accesskey=4 href="#Writing a User Entry">Writing a User Entry</a>:         How a program can rewrite a user's record. 
 </ul>
 
 <p><hr>
-Node:<a name="User%20Data%20Structure">User Data Structure</a>,
-Next:<a rel=next accesskey=n href="#Lookup%20User">Lookup User</a>,
-Up:<a rel=up accesskey=u href="#User%20Database">User Database</a>
+Node:<a name="User Data Structure">User Data Structure</a>,
+Next:<a rel=next accesskey=n href="#Lookup User">Lookup User</a>,
+Up:<a rel=up accesskey=u href="#User Database">User Database</a>
 <br>
 
 <h4>The Data Structure that Describes a User</h4>
 
 <p>The functions and data structures for accessing the system user database
 are declared in the header file <code>pwd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct passwd</b><i>
-</i></td>
+<td align="left"><code><b>struct passwd</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>passwd</code> data structure is used to hold information about
 entries in the system user data base.  It has at least the following members:
 
@@ -70673,12 +69183,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Lookup%20User">Lookup User</a>,
-Next:<a rel=next accesskey=n href="#Scanning%20All%20Users">Scanning All Users</a>,
-Previous:<a rel=previous accesskey=p href="#User%20Data%20Structure">User Data Structure</a>,
-Up:<a rel=up accesskey=u href="#User%20Database">User Database</a>
+Node:<a name="Lookup User">Lookup User</a>,
+Next:<a rel=next accesskey=n href="#Scanning All Users">Scanning All Users</a>,
+Previous:<a rel=previous accesskey=p href="#User Data Structure">User Data Structure</a>,
+Up:<a rel=up accesskey=u href="#User Database">User Database</a>
 <br>
 
 <h4>Looking Up One User</h4>
 
@@ -70686,16 +69196,15 @@
 specific user using <code>getpwuid</code> or <code>getpwnam</code>.  These
 functions are declared in <code>pwd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct passwd * <b>getpwuid</b><i> (uid_t <var>uid</var>)
-</i></td>
+<td align="left"><code>struct passwd * <b>getpwuid</b><i> (uid_t <var>uid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a pointer to a statically-allocated structure
 containing information about the user whose user ID is <var>uid</var>.  This
 structure may be overwritten on subsequent calls to <code>getpwuid</code>.
@@ -70705,16 +69214,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpwuid_r</b><i> (uid_t <var>uid</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getpwuid_r</b><i> (uid_t <var>uid</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getpwuid</code> in that it returns
 information about the user whose user ID is <var>uid</var>.  However, it
 fills the user supplied structure pointed to by <var>result_buf</var> with
@@ -70734,16 +69242,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct passwd * <b>getpwnam</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>struct passwd * <b>getpwnam</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a pointer to a statically-allocated structure
 containing information about the user whose user name is <var>name</var>. 
 This structure may be overwritten on subsequent calls to
@@ -70753,16 +69260,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpwnam_r</b><i> (const char *<var>name</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getpwnam_r</b><i> (const char *<var>name</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getpwnam</code> in that is returns
 information about the user whose user name is <var>name</var>.  However, like
 <code>getpwuid_r</code>, it fills the user supplied buffers in
@@ -70773,12 +69279,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Scanning%20All%20Users">Scanning All Users</a>,
-Next:<a rel=next accesskey=n href="#Writing%20a%20User%20Entry">Writing a User Entry</a>,
-Previous:<a rel=previous accesskey=p href="#Lookup%20User">Lookup User</a>,
-Up:<a rel=up accesskey=u href="#User%20Database">User Database</a>
+Node:<a name="Scanning All Users">Scanning All Users</a>,
+Next:<a rel=next accesskey=n href="#Writing a User Entry">Writing a User Entry</a>,
+Previous:<a rel=previous accesskey=p href="#Lookup User">Lookup User</a>,
+Up:<a rel=up accesskey=u href="#User Database">User Database</a>
 <br>
 
 <h4>Scanning the List of All Users</h4>
 
@@ -70789,16 +69295,15 @@
 <p>You can use the <code>fgetpwent</code> function to read user entries from a
 particular file.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct passwd * <b>fgetpwent</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>struct passwd * <b>fgetpwent</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads the next user entry from <var>stream</var> and returns a
 pointer to the entry.  The structure is statically allocated and is
 rewritten on subsequent calls to <code>fgetpwent</code>.  You must copy the
@@ -70809,16 +69314,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fgetpwent_r</b><i> (FILE *<var>stream</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>fgetpwent_r</b><i> (FILE *<var>stream</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fgetpwent</code> in that it reads the next
 user entry from <var>stream</var>.  But the result is returned in the
 structure pointed to by <var>result_buf</var>.  The
@@ -70839,31 +69343,29 @@
 <p>The way to scan all the entries in the user database is with
 <code>setpwent</code>, <code>getpwent</code>, and <code>endpwent</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setpwent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>setpwent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function initializes a stream which <code>getpwent</code> and
 <code>getpwent_r</code> use to read the user database. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct passwd * <b>getpwent</b><i> (void)
-</i></td>
+<td align="left"><code>struct passwd * <b>getpwent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getpwent</code> function reads the next entry from the stream
 initialized by <code>setpwent</code>.  It returns a pointer to the entry.  The
 structure is statically allocated and is rewritten on subsequent calls
@@ -70874,16 +69376,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getpwent_r</b><i> (struct passwd *<var>result_buf</var>, char *<var>buffer</var>, int <var>buflen</var>, struct passwd **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getpwent_r</b><i> (struct passwd *<var>result_buf</var>, char *<var>buffer</var>, int <var>buflen</var>, struct passwd **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getpwent</code> in that it returns the next
 entry from the stream initialized by <code>setpwent</code>.  Like
 <code>fgetpwent_r</code>, it uses the user-supplied buffers in
@@ -70894,39 +69395,37 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endpwent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endpwent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the internal stream used by <code>getpwent</code> or
 <code>getpwent_r</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Writing%20a%20User%20Entry">Writing a User Entry</a>,
-Previous:<a rel=previous accesskey=p href="#Scanning%20All%20Users">Scanning All Users</a>,
-Up:<a rel=up accesskey=u href="#User%20Database">User Database</a>
+Node:<a name="Writing a User Entry">Writing a User Entry</a>,
+Previous:<a rel=previous accesskey=p href="#Scanning All Users">Scanning All Users</a>,
+Up:<a rel=up accesskey=u href="#User Database">User Database</a>
 <br>
 
 <h4>Writing a User Entry</h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>putpwent</b><i> (const struct passwd *<var>p</var>, FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>putpwent</b><i> (const struct passwd *<var>p</var>, FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function writes the user entry <code>*<var>p</var></code> to the stream
 <var>stream</var>, in the format used for the standard user database
 file.  The return value is zero on success and nonzero on failure.
@@ -70942,12 +69441,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Group%20Database">Group Database</a>,
-Next:<a rel=next accesskey=n href="#Database%20Example">Database Example</a>,
-Previous:<a rel=previous accesskey=p href="#User%20Database">User Database</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Group Database">Group Database</a>,
+Next:<a rel=next accesskey=n href="#Database Example">Database Example</a>,
+Previous:<a rel=previous accesskey=p href="#User Database">User Database</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Group Database</h3>
 
@@ -70956,33 +69455,32 @@
 <code>/etc/group</code> on most systems, but on some systems a special network
 service provides access to it.
 
 <ul>
-<li><a accesskey=1 href="#Group%20Data%20Structure">Group Data Structure</a>:         What each group record contains. 
-<li><a accesskey=2 href="#Lookup%20Group">Lookup Group</a>:                 How to look for a particular group. 
-<li><a accesskey=3 href="#Scanning%20All%20Groups">Scanning All Groups</a>:          Scanning the list of all groups. 
+<li><a accesskey=1 href="#Group Data Structure">Group Data Structure</a>:         What each group record contains. 
+<li><a accesskey=2 href="#Lookup Group">Lookup Group</a>:                 How to look for a particular group. 
+<li><a accesskey=3 href="#Scanning All Groups">Scanning All Groups</a>:          Scanning the list of all groups. 
 </ul>
 
 <p><hr>
-Node:<a name="Group%20Data%20Structure">Group Data Structure</a>,
-Next:<a rel=next accesskey=n href="#Lookup%20Group">Lookup Group</a>,
-Up:<a rel=up accesskey=u href="#Group%20Database">Group Database</a>
+Node:<a name="Group Data Structure">Group Data Structure</a>,
+Next:<a rel=next accesskey=n href="#Lookup Group">Lookup Group</a>,
+Up:<a rel=up accesskey=u href="#Group Database">Group Database</a>
 <br>
 
 <h4>The Data Structure for a Group</h4>
 
 <p>The functions and data structures for accessing the system group
 database are declared in the header file <code>grp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct group</b><i>
-</i></td>
+<td align="left"><code><b>struct group</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>group</code> structure is used to hold information about an entry in
 the system group database.  It has at least the following members:
 
@@ -71001,12 +69499,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Lookup%20Group">Lookup Group</a>,
-Next:<a rel=next accesskey=n href="#Scanning%20All%20Groups">Scanning All Groups</a>,
-Previous:<a rel=previous accesskey=p href="#Group%20Data%20Structure">Group Data Structure</a>,
-Up:<a rel=up accesskey=u href="#Group%20Database">Group Database</a>
+Node:<a name="Lookup Group">Lookup Group</a>,
+Next:<a rel=next accesskey=n href="#Scanning All Groups">Scanning All Groups</a>,
+Previous:<a rel=previous accesskey=p href="#Group Data Structure">Group Data Structure</a>,
+Up:<a rel=up accesskey=u href="#Group Database">Group Database</a>
 <br>
 
 <h4>Looking Up One Group</h4>
 
@@ -71014,16 +69512,15 @@
 group using <code>getgrgid</code> or <code>getgrnam</code>.  These functions are
 declared in <code>grp.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct group * <b>getgrgid</b><i> (gid_t <var>gid</var>)
-</i></td>
+<td align="left"><code>struct group * <b>getgrgid</b><i> (gid_t <var>gid</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a pointer to a statically-allocated structure
 containing information about the group whose group ID is <var>gid</var>. 
 This structure may be overwritten by subsequent calls to
@@ -71033,16 +69530,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getgrgid_r</b><i> (gid_t <var>gid</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getgrgid_r</b><i> (gid_t <var>gid</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getgrgid</code> in that it returns
 information about the group whose group ID is <var>gid</var>.  However, it
 fills the user supplied structure pointed to by <var>result_buf</var> with
@@ -71062,16 +69558,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct group * <b>getgrnam</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>struct group * <b>getgrnam</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns a pointer to a statically-allocated structure
 containing information about the group whose group name is <var>name</var>. 
 This structure may be overwritten by subsequent calls to
@@ -71081,16 +69576,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getgrnam_r</b><i> (const char *<var>name</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getgrnam_r</b><i> (const char *<var>name</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getgrnam</code> in that is returns
 information about the group whose group name is <var>name</var>.  Like
 <code>getgrgid_r</code>, it uses the user supplied buffers in
@@ -71101,11 +69595,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Scanning%20All%20Groups">Scanning All Groups</a>,
-Previous:<a rel=previous accesskey=p href="#Lookup%20Group">Lookup Group</a>,
-Up:<a rel=up accesskey=u href="#Group%20Database">Group Database</a>
+Node:<a name="Scanning All Groups">Scanning All Groups</a>,
+Previous:<a rel=previous accesskey=p href="#Lookup Group">Lookup Group</a>,
+Up:<a rel=up accesskey=u href="#Group Database">Group Database</a>
 <br>
 
 <h4>Scanning the List of All Groups</h4>
 
@@ -71116,16 +69610,15 @@
 <p>You can use the <code>fgetgrent</code> function to read group entries from a
 particular file.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct group * <b>fgetgrent</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>struct group * <b>fgetgrent</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>fgetgrent</code> function reads the next entry from <var>stream</var>. 
 It returns a pointer to the entry.  The structure is statically
 allocated and is overwritten on subsequent calls to <code>fgetgrent</code>.  You
@@ -71137,16 +69630,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>fgetgrent_r</b><i> (FILE *<var>stream</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>fgetgrent_r</b><i> (FILE *<var>stream</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>fgetgrent</code> in that it reads the next
 user entry from <var>stream</var>.  But the result is returned in the
 structure pointed to by <var>result_buf</var>.  The first <var>buflen</var> bytes
@@ -71167,31 +69659,29 @@
 <p>The way to scan all the entries in the group database is with
 <code>setgrent</code>, <code>getgrent</code>, and <code>endgrent</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setgrent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>setgrent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function initializes a stream for reading from the group data base. 
 You use this stream by calling <code>getgrent</code> or <code>getgrent_r</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct group * <b>getgrent</b><i> (void)
-</i></td>
+<td align="left"><code>struct group * <b>getgrent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getgrent</code> function reads the next entry from the stream
 initialized by <code>setgrent</code>.  It returns a pointer to the entry.  The
 structure is statically allocated and is overwritten on subsequent calls
@@ -71200,16 +69690,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getgrent_r</b><i> (struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)
-</i></td>
+<td align="left"><code>int <b>getgrent_r</b><i> (struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getgrent</code> in that it returns the next
 entry from the stream initialized by <code>setgrent</code>.  Like
 <code>fgetgrent_r</code>, it places the result in user-supplied buffers
@@ -71221,27 +69710,26 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endgrent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endgrent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function closes the internal stream used by <code>getgrent</code> or
 <code>getgrent_r</code>. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Database%20Example">Database Example</a>,
-Next:<a rel=next accesskey=n href="#Netgroup%20Database">Netgroup Database</a>,
-Previous:<a rel=previous accesskey=p href="#Group%20Database">Group Database</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Database Example">Database Example</a>,
+Next:<a rel=next accesskey=n href="#Netgroup Database">Netgroup Database</a>,
+Previous:<a rel=previous accesskey=p href="#Group Database">Group Database</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>User and Group Database Example</h3>
 
@@ -71318,32 +69806,32 @@
   tami
 </pre>
 
 <p><hr>
-Node:<a name="Netgroup%20Database">Netgroup Database</a>,
-Previous:<a rel=previous accesskey=p href="#Database%20Example">Database Example</a>,
-Up:<a rel=up accesskey=u href="#Users%20and%20Groups">Users and Groups</a>
+Node:<a name="Netgroup Database">Netgroup Database</a>,
+Previous:<a rel=previous accesskey=p href="#Database Example">Database Example</a>,
+Up:<a rel=up accesskey=u href="#Users and Groups">Users and Groups</a>
 <br>
 
 <h3>Netgroup Database</h3>
 
 <ul>
-<li><a accesskey=1 href="#Netgroup%20Data">Netgroup Data</a>:                   Data in the Netgroup database and where
+<li><a accesskey=1 href="#Netgroup Data">Netgroup Data</a>:                   Data in the Netgroup database and where
                                    it comes from. 
-<li><a accesskey=2 href="#Lookup%20Netgroup">Lookup Netgroup</a>:                 How to look for a particular netgroup. 
-<li><a accesskey=3 href="#Netgroup%20Membership">Netgroup Membership</a>:             How to test for netgroup membership. 
+<li><a accesskey=2 href="#Lookup Netgroup">Lookup Netgroup</a>:                 How to look for a particular netgroup. 
+<li><a accesskey=3 href="#Netgroup Membership">Netgroup Membership</a>:             How to test for netgroup membership. 
 </ul>
 
 <p><hr>
-Node:<a name="Netgroup%20Data">Netgroup Data</a>,
-Next:<a rel=next accesskey=n href="#Lookup%20Netgroup">Lookup Netgroup</a>,
-Up:<a rel=up accesskey=u href="#Netgroup%20Database">Netgroup Database</a>
+Node:<a name="Netgroup Data">Netgroup Data</a>,
+Next:<a rel=next accesskey=n href="#Lookup Netgroup">Lookup Netgroup</a>,
+Up:<a rel=up accesskey=u href="#Netgroup Database">Netgroup Database</a>
 <br>
 
 <h4>Netgroup Data</h4>
 
 <p>Sometimes it is useful to group users according to other criteria
-(see <a href="#Group%20Database">Group Database</a>).  E.g., it is useful to associate a certain
+(see <a href="#Group Database">Group Database</a>).  E.g., it is useful to associate a certain
 group of users with a certain machine.  On the other hand grouping of
 host names is not supported so far.
 
 <p>In Sun Microsystems SunOS appeared a new kind of database, the netgroup
@@ -71355,9 +69843,9 @@
 list specifying a netgroup.  So one can construct arbitrary hierarchies
 without loops.
 
 <p>Sun's implementation allows netgroups only for the <code>nis</code> or
-<code>nisplus</code> service, see <a href="#Services%20in%20the%20NSS%20configuration">Services in the NSS configuration</a>.  The
+<code>nisplus</code> service, see <a href="#Services in the NSS configuration">Services in the NSS configuration</a>.  The
 implementation in the GNU C library has no such restriction.  An entry
 in either of the input services must have the following form:
 
 <br><pre><var>groupname</var> ( <var>groupname</var> | <code>(</code><var>hostname</var><code>,</code><var>username</var><code>,</code><code>domainname</code><code>)</code> )+
@@ -71369,12 +69857,12 @@
 match any input.  For entries like this, a name consisting of the single
 character <code>-</code> shall be used.
 
 <p><hr>
-Node:<a name="Lookup%20Netgroup">Lookup Netgroup</a>,
-Next:<a rel=next accesskey=n href="#Netgroup%20Membership">Netgroup Membership</a>,
-Previous:<a rel=previous accesskey=p href="#Netgroup%20Data">Netgroup Data</a>,
-Up:<a rel=up accesskey=u href="#Netgroup%20Database">Netgroup Database</a>
+Node:<a name="Lookup Netgroup">Lookup Netgroup</a>,
+Next:<a rel=next accesskey=n href="#Netgroup Membership">Netgroup Membership</a>,
+Previous:<a rel=previous accesskey=p href="#Netgroup Data">Netgroup Data</a>,
+Up:<a rel=up accesskey=u href="#Netgroup Database">Netgroup Database</a>
 <br>
 
 <h4>Looking up one Netgroup</h4>
 
@@ -71384,16 +69872,15 @@
 selected and then one can iterate over all entries in this netgroup. 
 These functions are declared in <code>netdb.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setnetgrent</b><i> (const char *<var>netgroup</var>)
-</i></td>
+<td align="left"><code>int <b>setnetgrent</b><i> (const char *<var>netgroup</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 A call to this function initializes the internal state of the library to
 allow following calls of the <code>getnetgrent</code> to iterate over all entries
 in the netgroup with name <var>netgroup</var>.
@@ -71417,16 +69904,15 @@
 the <code>innetgr</code> function and parts of the implementation of the
 <code>compat</code> service part of the NSS implementation.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getnetgrent</b><i> (char **<var>hostp</var>, char **<var>userp</var>, char **<var>domainp</var>)
-</i></td>
+<td align="left"><code>int <b>getnetgrent</b><i> (char **<var>hostp</var>, char **<var>userp</var>, char **<var>domainp</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next unprocessed entry of the currently
 selected netgroup.  The string pointers, in which addresses are passed in
 the arguments <var>hostp</var>, <var>userp</var>, and <var>domainp</var>, will contain
@@ -71440,16 +69926,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getnetgrent_r</b><i> (char **<var>hostp</var>, char **<var>userp</var>, char **<var>domainp</var>, char *<var>buffer</var>, int <var>buflen</var>)
-</i></td>
+<td align="left"><code>int <b>getnetgrent_r</b><i> (char **<var>hostp</var>, char **<var>userp</var>, char **<var>domainp</var>, char *<var>buffer</var>, int <var>buflen</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is similar to <code>getnetgrent</code> with only one exception:
 the strings the three string pointers <var>hostp</var>, <var>userp</var>, and
 <var>domainp</var> point to, are placed in the buffer of <var>buflen</var> bytes
@@ -71466,27 +69951,26 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endnetgrent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endnetgrent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function frees all buffers which were allocated to process the last
 selected netgroup.  As a result all string pointers returned by calls
 to <code>getnetgrent</code> are invalid afterwards. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Netgroup%20Membership">Netgroup Membership</a>,
-Previous:<a rel=previous accesskey=p href="#Lookup%20Netgroup">Lookup Netgroup</a>,
-Up:<a rel=up accesskey=u href="#Netgroup%20Database">Netgroup Database</a>
+Node:<a name="Netgroup Membership">Netgroup Membership</a>,
+Previous:<a rel=previous accesskey=p href="#Lookup Netgroup">Lookup Netgroup</a>,
+Up:<a rel=up accesskey=u href="#Netgroup Database">Netgroup Database</a>
 <br>
 
 <h4>Testing for Netgroup Membership</h4>
 
@@ -71494,16 +69978,15 @@
 only interesting question is whether a given entry is part of the
 selected netgroup.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>innetgr</b><i> (const char *<var>netgroup</var>, const char *<var>host</var>, const char *<var>user</var>, const char *<var>domain</var>)
-</i></td>
+<td align="left"><code>int <b>innetgr</b><i> (const char *<var>netgroup</var>, const char *<var>host</var>, const char *<var>user</var>, const char *<var>domain</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function tests whether the triple specified by the parameters
 <var>hostp</var>, <var>userp</var>, and <var>domainp</var> is part of the netgroup
 <var>netgroup</var>.  Using this function has the advantage that
@@ -71527,11 +70010,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="System%20Management">System Management</a>,
-Next:<a rel=next accesskey=n href="#System%20Configuration">System Configuration</a>,
-Previous:<a rel=previous accesskey=p href="#Users%20and%20Groups">Users and Groups</a>,
+Node:<a name="System Management">System Management</a>,
+Next:<a rel=next accesskey=n href="#System Configuration">System Configuration</a>,
+Previous:<a rel=previous accesskey=p href="#Users and Groups">Users and Groups</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>System Management</h2>
@@ -71542,22 +70025,22 @@
 informational facilities, but usually only a properly privileged process
 can make changes.
 
 <ul>
-<li><a accesskey=1 href="#Host%20Identification">Host Identification</a>:          Determining the name of the machine. 
-<li><a accesskey=2 href="#Platform%20Type">Platform Type</a>:                Determining operating system and basic
+<li><a accesskey=1 href="#Host Identification">Host Identification</a>:          Determining the name of the machine. 
+<li><a accesskey=2 href="#Platform Type">Platform Type</a>:                Determining operating system and basic
                                   machine type
-<li><a accesskey=3 href="#Filesystem%20Handling">Filesystem Handling</a>:          Controlling/querying mounts
-<li><a accesskey=4 href="#System%20Parameters">System Parameters</a>:            Getting and setting various system parameters
+<li><a accesskey=3 href="#Filesystem Handling">Filesystem Handling</a>:          Controlling/querying mounts
+<li><a accesskey=4 href="#System Parameters">System Parameters</a>:            Getting and setting various system parameters
 </ul>
 
 <p>To get information on parameters of the system that are built into the
-system, such as the maximum length of a filename, <a href="#System%20Configuration">System Configuration</a>.
+system, such as the maximum length of a filename, <a href="#System Configuration">System Configuration</a>.
 
 <p><hr>
-Node:<a name="Host%20Identification">Host Identification</a>,
-Next:<a rel=next accesskey=n href="#Platform%20Type">Platform Type</a>,
-Up:<a rel=up accesskey=u href="#System%20Management">System Management</a>
+Node:<a name="Host Identification">Host Identification</a>,
+Next:<a rel=next accesskey=n href="#Platform Type">Platform Type</a>,
+Up:<a rel=up accesskey=u href="#System Management">System Management</a>
 <br>
 
 <h3>Host Identification</h3>
 
@@ -71602,24 +70085,23 @@
 canonical FQDN.
 
 <p>In some contexts, the host name is called a "node name."
 
-<p>For more information on DNS host naming, See <a href="#Host%20Names">Host Names</a>.
+<p>For more information on DNS host naming, See <a href="#Host Names">Host Names</a>.
 
 <p>Prototypes for these functions appear in <code>unistd.h</code>.
 
 <p>The programs <code>hostname</code>, <code>hostid</code>, and <code>domainname</code> work
 by calling these functions.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>gethostname</b><i> (char *<var>name</var>, size_t <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>gethostname</b><i> (char *<var>name</var>, size_t <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the host name of the system on which it is called,
 in the array <var>name</var>.  The <var>size</var> argument specifies the size of
 this array, in bytes.  Note that this is <em>not</em> the DNS hostname. 
@@ -71647,16 +70129,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sethostname</b><i> (const char *<var>name</var>, size_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>sethostname</b><i> (const char *<var>name</var>, size_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sethostname</code> function sets the host name of the system that
 calls it to <var>name</var>, a string with length <var>length</var>.  Only
 privileged processes are permitted to do this.
@@ -71678,16 +70159,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>getdomainnname</b><i> (char *<var>name</var>, size_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>getdomainnname</b><i> (char *<var>name</var>, size_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>getdomainname</code> returns the NIS (aka YP) domain name of the system
 on which it is called.  Note that this is not the more popular DNS
@@ -71698,16 +70178,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setdomainname</b><i> (const char *<var>name</var>, size_t <var>length</var>)
-</i></td>
+<td align="left"><code>int <b>setdomainname</b><i> (const char *<var>name</var>, size_t <var>length</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>getdomainname</code> sets the NIS (aka YP) domain name of the system
 on which it is called.  Note that this is not the more popular DNS
@@ -71718,16 +70197,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>gethostid</b><i> (void)
-</i></td>
+<td align="left"><code>long int <b>gethostid</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the "host ID" of the machine the program is
 running on.  By convention, this is usually the primary Internet IP address
 of that machine, converted to a <code>long&nbsp;int</code>.  However, on some
@@ -71738,21 +70216,20 @@
 It is not required by POSIX.
 
 <p>The proper way to query the IP address is to use <code>gethostbyname</code>
 on the results of <code>gethostname</code>.  For more information on IP addresses,
-See <a href="#Host%20Addresses">Host Addresses</a>. 
+See <a href="#Host Addresses">Host Addresses</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sethostid</b><i> (long int <var>id</var>)
-</i></td>
+<td align="left"><code>int <b>sethostid</b><i> (long int <var>id</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>sethostid</code> function sets the "host ID" of the host machine
 to <var>id</var>.  Only privileged processes are permitted to do this.  Usually
 it happens just once, at system boot time.
@@ -71779,12 +70256,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Platform%20Type">Platform Type</a>,
-Next:<a rel=next accesskey=n href="#Filesystem%20Handling">Filesystem Handling</a>,
-Previous:<a rel=previous accesskey=p href="#Host%20Identification">Host Identification</a>,
-Up:<a rel=up accesskey=u href="#System%20Management">System Management</a>
+Node:<a name="Platform Type">Platform Type</a>,
+Next:<a rel=next accesskey=n href="#Filesystem Handling">Filesystem Handling</a>,
+Previous:<a rel=previous accesskey=p href="#Host Identification">Host Identification</a>,
+Up:<a rel=up accesskey=u href="#System Management">System Management</a>
 <br>
 
 <h3>Platform Type Identification</h3>
 
@@ -71795,19 +70272,18 @@
 
 <p>As a bonus, <code>uname</code> also gives some information identifying the
 particular system your program is running on.  This is the same information
 which you can get with functions targetted to this purpose described in
-<a href="#Host%20Identification">Host Identification</a>.
+<a href="#Host Identification">Host Identification</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct utsname</b><i>
-</i></td>
+<td align="left"><code><b>struct utsname</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>utsname</code> structure is used to hold information returned
 by the <code>uname</code> function.  It has the following members:
 
@@ -71852,31 +70328,30 @@
 
 <br><dt><code>char nodename[]</code>
 <dd>This is the host name of this particular computer.  In the GNU C
 library, the value is the same as that returned by <code>gethostname</code>;
-see <a href="#Host%20Identification">Host Identification</a>.
+see <a href="#Host Identification">Host Identification</a>.
 
 <p>gethostname() is implemented with a call to uname().
 
 <br><dt><code>char domainname[]</code>
 <dd>This is the NIS or YP domain name.  It is the same value returned by
-<code>getdomainname</code>; see <a href="#Host%20Identification">Host Identification</a>.  This element
+<code>getdomainname</code>; see <a href="#Host Identification">Host Identification</a>.  This element
 is a relatively recent invention and use of it is not as portable as
 use of the rest of the structure.
 
 </dl>
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>uname</b><i> (struct utsname *<var>info</var>)
-</i></td>
+<td align="left"><code>int <b>uname</b><i> (struct utsname *<var>info</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>uname</code> function fills in the structure pointed to by
 <var>info</var> with information about the operating system and host machine. 
 A non-negative value indicates that the data was successfully stored.
@@ -71887,12 +70362,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Filesystem%20Handling">Filesystem Handling</a>,
-Next:<a rel=next accesskey=n href="#System%20Parameters">System Parameters</a>,
-Previous:<a rel=previous accesskey=p href="#Platform%20Type">Platform Type</a>,
-Up:<a rel=up accesskey=u href="#System%20Management">System Management</a>
+Node:<a name="Filesystem Handling">Filesystem Handling</a>,
+Next:<a rel=next accesskey=n href="#System Parameters">System Parameters</a>,
+Previous:<a rel=previous accesskey=p href="#Platform Type">Platform Type</a>,
+Up:<a rel=up accesskey=u href="#System Management">System Management</a>
 <br>
 
 <h3>Controlling and Querying Mounts</h3>
 
@@ -71919,16 +70394,16 @@
 write to it, the data you write causes changes in the system.  No data
 gets stored.
 
 <ul>
-<li><a accesskey=1 href="#Mount%20Information">Mount Information</a>:            What is or could be mounted? 
+<li><a accesskey=1 href="#Mount Information">Mount Information</a>:            What is or could be mounted? 
 <li><a accesskey=2 href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>:        Controlling what is mounted and how
 </ul>
 
 <p><hr>
-Node:<a name="Mount%20Information">Mount Information</a>,
+Node:<a name="Mount Information">Mount Information</a>,
 Next:<a rel=next accesskey=n href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>,
-Up:<a rel=up accesskey=u href="#Filesystem%20Handling">Filesystem Handling</a>
+Up:<a rel=up accesskey=u href="#Filesystem Handling">Filesystem Handling</a>
 <br>
 
 <h4>Mount Information</h4>
 
@@ -71965,30 +70440,29 @@
 
 <ul>
 <li><a accesskey=1 href="#fstab">fstab</a>:                        The <code>fstab</code> file
 <li><a accesskey=2 href="#mtab">mtab</a>:                         The <code>mtab</code> file
-<li><a accesskey=3 href="#Other%20Mount%20Information">Other Mount Information</a>:      Other (non-libc) sources of mount information
+<li><a accesskey=3 href="#Other Mount Information">Other Mount Information</a>:      Other (non-libc) sources of mount information
 </ul>
 
 <p><hr>
 Node:<a name="fstab">fstab</a>,
 Next:<a rel=next accesskey=n href="#mtab">mtab</a>,
-Up:<a rel=up accesskey=u href="#Mount%20Information">Mount Information</a>
+Up:<a rel=up accesskey=u href="#Mount Information">Mount Information</a>
 <br>
 
 <h5>The <code>fstab</code> file</h5>
 
 <p>The internal representation for entries of the file is <code>struct&nbsp;fstab</code>, defined in <code>fstab.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct fstab</b><i>
-</i></td>
+<td align="left"><code><b>struct fstab</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used with the <code>getfsent</code>, <code>getfsspec</code>, and
 <code>getfsfile</code> functions.
 
@@ -72060,16 +70534,15 @@
 <p>To read the entire content of the of the <code>fstab</code> file the GNU libc
 contains a set of three functions which are designed in the usual way.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>setfsent</b><i> (void)
-</i></td>
+<td align="left"><code>int <b>setfsent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function makes sure that the internal read pointer for the
 <code>fstab</code> file is at the beginning of the file.  This is done by
 either opening the file or resetting the read pointer.
@@ -72083,32 +70556,30 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>endfsent</b><i> (void)
-</i></td>
+<td align="left"><code>void <b>endfsent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function makes sure that all resources acquired by a prior call to
 <code>setfsent</code> (explicitly or implicitly by calling <code>getfsent</code>) are
 freed. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct fstab * <b>getfsent</b><i> (void)
-</i></td>
+<td align="left"><code>struct fstab * <b>getfsent</b><i> (void)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next entry of the <code>fstab</code> file.  If this
 is the first call to any of the functions handling <code>fstab</code> since
 program start or the last call of <code>endfsent</code>, the file will be
@@ -72121,16 +70592,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct fstab * <b>getfsspec</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>struct fstab * <b>getfsspec</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next entry of the <code>fstab</code> file which has
 a string equal to <var>name</var> pointed to by the <code>fs_spec</code> element. 
 Since there is normally exactly one entry for each special device it
@@ -72146,16 +70616,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct fstab * <b>getfsfile</b><i> (const char *<var>name</var>)
-</i></td>
+<td align="left"><code>struct fstab * <b>getfsfile</b><i> (const char *<var>name</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function returns the next entry of the <code>fstab</code> file which has
 a string equal to <var>name</var> pointed to by the <code>fs_file</code> element. 
 Since there is normally exactly one entry for each mount point it
@@ -72172,26 +70641,25 @@
 </table>
 
 <p><hr>
 Node:<a name="mtab">mtab</a>,
-Next:<a rel=next accesskey=n href="#Other%20Mount%20Information">Other Mount Information</a>,
+Next:<a rel=next accesskey=n href="#Other Mount Information">Other Mount Information</a>,
 Previous:<a rel=previous accesskey=p href="#fstab">fstab</a>,
-Up:<a rel=up accesskey=u href="#Mount%20Information">Mount Information</a>
+Up:<a rel=up accesskey=u href="#Mount Information">Mount Information</a>
 <br>
 
 <h5>The <code>mtab</code> file</h5>
 
 <p>The following functions and data structure access the <code>mtab</code> file.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>struct mntent</b><i>
-</i></td>
+<td align="left"><code><b>struct mntent</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This structure is used with the <code>getmntent</code>, <code>getmntent_t</code>,
 <code>addmntent</code>, and <code>hasmntopt</code> functions.
 
@@ -72250,9 +70718,9 @@
 <br><dt><code>MNTOPT_RW</code>
 <dd>Expand to <code>"rw"</code>.  See the <code>FSTAB_RW</code> value, it means the
 filesystem is mounted with read and write permissions. 
 <br><dt><code>MNTOPT_SUID</code>
-<dd>Expands to <code>"suid"</code>.  This means that the SUID bit (see <a href="#How%20Change%20Persona">How Change Persona</a>) is respected when a program from the filesystem is
+<dd>Expands to <code>"suid"</code>.  This means that the SUID bit (see <a href="#How Change Persona">How Change Persona</a>) is respected when a program from the filesystem is
 started. 
 <br><dt><code>MNTOPT_NOSUID</code>
 <dd>Expands to <code>"nosuid"</code>.  This is the opposite of <code>MNTOPT_SUID</code>,
 the SUID bit for all files from the filesystem is ignored. 
@@ -72282,22 +70750,21 @@
 is even a thread safe variant of the get function.  Beside this the GNU
 libc contains functions to alter the file and test for specific options.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">FILE * <b>setmntent</b><i> (const char *<var>file</var>, const char *<var>mode</var>)
-</i></td>
+<td align="left"><code>FILE * <b>setmntent</b><i> (const char *<var>file</var>, const char *<var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>setmntent</code> function prepares the file named <var>FILE</var> which
 must be in the format of a <code>fstab</code> and <code>mtab</code> file for the
 upcoming processing through the other functions of the family.  The
 <var>mode</var> parameter can be chosen in the way the <var>opentype</var>
-parameter for <code>fopen</code> (see <a href="#Opening%20Streams">Opening Streams</a>) can be chosen.  If
+parameter for <code>fopen</code> (see <a href="#Opening Streams">Opening Streams</a>) can be chosen.  If
 the file is opened for writing the file is also allowed to be empty.
 
 <p>If the file was successfully opened <code>setmntent</code> returns a file
 descriptor for future use.  Otherwise the return value is <code>NULL</code>
@@ -72305,16 +70772,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>endmntent</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>int <b>endmntent</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function takes for the <var>stream</var> parameter a file handle which
 previously was returned from the <code>setmntent</code> call. 
 <code>endmntent</code> closes the stream and frees all resources.
@@ -72324,16 +70790,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct mntent * <b>getmntent</b><i> (FILE *<var>stream</var>)
-</i></td>
+<td align="left"><code>struct mntent * <b>getmntent</b><i> (FILE *<var>stream</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getmntent</code> function takes as the parameter a file handle
 previously returned by successful call to <code>setmntent</code>.  It returns
 a pointer to a static variable of type <code>struct mntent</code> which is
@@ -72357,16 +70822,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">struct mntent * <b>getmntent_r</b><i> (FILE *<var>stream</var>, struct mentent *<var>result</var>, char *<var>buffer</var>, int <var>bufsize</var>)
-</i></td>
+<td align="left"><code>struct mntent * <b>getmntent_r</b><i> (FILE *<var>stream</var>, struct mentent *<var>result</var>, char *<var>buffer</var>, int <var>bufsize</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>getmntent_r</code> function is the reentrant variant of
 <code>getmntent</code>.  It also returns the next entry from the file and
 returns a pointer.  The actual variable the values are stored in is not
@@ -72387,16 +70851,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>addmntent</b><i> (FILE *<var>stream</var>, const struct mntent *<var>mnt</var>)
-</i></td>
+<td align="left"><code>int <b>addmntent</b><i> (FILE *<var>stream</var>, const struct mntent *<var>mnt</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>addmntent</code> function allows adding a new entry to the file
 previously opened with <code>setmntent</code>.  The new entries are always
 appended.  I.e., even if the position of the file descriptor is not at
@@ -72418,16 +70881,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>hasmntopt</b><i> (const struct mntent *<var>mnt</var>, const char *<var>opt</var>)
-</i></td>
+<td align="left"><code>char * <b>hasmntopt</b><i> (const struct mntent *<var>mnt</var>, const char *<var>opt</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function can be used to check whether the string pointed to by the
 <code>mnt_opts</code> element of the variable pointed to by <var>mnt</var> contains
 the option <var>opt</var>.  If this is true a pointer to the beginning of the
@@ -72440,11 +70902,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Other%20Mount%20Information">Other Mount Information</a>,
+Node:<a name="Other Mount Information">Other Mount Information</a>,
 Previous:<a rel=previous accesskey=p href="#mtab">mtab</a>,
-Up:<a rel=up accesskey=u href="#Mount%20Information">Mount Information</a>
+Up:<a rel=up accesskey=u href="#Mount Information">Mount Information</a>
 <br>
 
 <h5>Other (Non-libc) Sources of Mount Information</h5>
 
@@ -72456,10 +70918,10 @@
 to date.
 
 <p><hr>
 Node:<a name="Mount-Unmount-Remount">Mount-Unmount-Remount</a>,
-Previous:<a rel=previous accesskey=p href="#Mount%20Information">Mount Information</a>,
-Up:<a rel=up accesskey=u href="#Filesystem%20Handling">Filesystem Handling</a>
+Previous:<a rel=previous accesskey=p href="#Mount Information">Mount Information</a>,
+Up:<a rel=up accesskey=u href="#Filesystem Handling">Filesystem Handling</a>
 <br>
 
 <h4>Mount, Unmount, Remount</h4>
 
@@ -72468,21 +70930,20 @@
 
 <p>Only the superuser can mount, unmount, or remount a filesystem.
 
 <p>These functions do not access the <code>fstab</code> and <code>mtab</code> files.  You
-should maintain and use these separately.  See <a href="#Mount%20Information">Mount Information</a>.
+should maintain and use these separately.  See <a href="#Mount Information">Mount Information</a>.
 
 <p>The symbols in this section are declared in <code>sys/mount.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>mount</b><i> (const char *<var>special_file</var>, const char *<var>dir</var>, const char *<var>fstype</var>, unsigned long int <var>options</var>, const void *<var>data</var>)
-</i></td>
+<td align="left"><code>int <b>mount</b><i> (const char *<var>special_file</var>, const char *<var>dir</var>, const char *<var>fstype</var>, unsigned long int <var>options</var>, const void *<var>data</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>mount</code> mounts or remounts a filesystem.  The two operations are
 quite different and are merged rather unnaturally into this one function. 
@@ -72603,9 +71064,9 @@
 mount("/dev/hda2", "/mnt", MS_MGC_VAL | MS_REMOUNT, "");
 </pre>
 
 <p>Appropriate arguments for <code>mount</code> are conventionally recorded in
-the <code>fstab</code> table.  See <a href="#Mount%20Information">Mount Information</a>.
+the <code>fstab</code> table.  See <a href="#Mount Information">Mount Information</a>.
 
 <p>The return value is zero if the mount or remount is successful.  Otherwise,
 it is <code>-1</code> and <code>errno</code> is set appropriately.  The values of
 <code>errno</code> are filesystem dependent, but here is a general list:
@@ -72665,16 +71126,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>umount2</b><i> (const char *<var>file</var>, int <var>flags</var>)
-</i></td>
+<td align="left"><code>int <b>umount2</b><i> (const char *<var>file</var>, int <var>flags</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>umount2</code> unmounts a filesystem.
 
@@ -72734,16 +71194,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>umount</b><i> (const char *<var>file</var>)
-</i></td>
+<td align="left"><code>int <b>umount</b><i> (const char *<var>file</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>umount</code> does the same thing as <code>umount2</code> with <var>flags</var> set
 to zeroes.  It is more widely available than <code>umount2</code> but since it
@@ -72752,11 +71211,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="System%20Parameters">System Parameters</a>,
-Previous:<a rel=previous accesskey=p href="#Filesystem%20Handling">Filesystem Handling</a>,
-Up:<a rel=up accesskey=u href="#System%20Management">System Management</a>
+Node:<a name="System Parameters">System Parameters</a>,
+Previous:<a rel=previous accesskey=p href="#Filesystem Handling">Filesystem Handling</a>,
+Up:<a rel=up accesskey=u href="#System Management">System Management</a>
 <br>
 
 <h3>System Parameters</h3>
 
@@ -72765,16 +71224,15 @@
 
 <p>The symbols used in this section are declared in the file <code>sysctl.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>sysctl</b><i> (int *<var>names</var>, int <var>nlen</var>, void *<var>oldval</var>,
-</i></td>
+<td align="left"><code>int <b>sysctl</b><i> (int *<var>names</var>, int <var>nlen</var>, void *<var>oldval</var>,</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
         size_t *<var>oldlenp</var>, void *<var>newval</var>, size_t <var>newlen</var>)
 
 <p><code>sysctl</code> gets or sets a specified system parameter.  There are so
@@ -72887,57 +71345,57 @@
 parameters are:
 
 <ul>
 <li><code>getdomainname</code>, <code>setdomainname</code>
-<li><code>gethostname</code>, <code>sethostname</code> (See <a href="#Host%20Identification">Host Identification</a>.) 
-<li><code>uname</code> (See <a href="#Platform%20Type">Platform Type</a>.) 
+<li><code>gethostname</code>, <code>sethostname</code> (See <a href="#Host Identification">Host Identification</a>.) 
+<li><code>uname</code> (See <a href="#Platform Type">Platform Type</a>.) 
 <li><code>bdflush</code>
 </ul>
 
 <p><hr>
-Node:<a name="System%20Configuration">System Configuration</a>,
-Next:<a rel=next accesskey=n href="#Cryptographic%20Functions">Cryptographic Functions</a>,
-Previous:<a rel=previous accesskey=p href="#System%20Management">System Management</a>,
+Node:<a name="System Configuration">System Configuration</a>,
+Next:<a rel=next accesskey=n href="#Cryptographic Functions">Cryptographic Functions</a>,
+Previous:<a rel=previous accesskey=p href="#System Management">System Management</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>System Configuration Parameters</h2>
 
 <p>The functions and macros listed in this chapter give information about
 configuration parameters of the operating system--for example, capacity
 limits, presence of optional POSIX features, and the default path for
-executable files (see <a href="#String%20Parameters">String Parameters</a>).
+executable files (see <a href="#String Parameters">String Parameters</a>).
 
 <ul>
-<li><a accesskey=1 href="#General%20Limits">General Limits</a>:            Constants and functions that describe
+<li><a accesskey=1 href="#General Limits">General Limits</a>:            Constants and functions that describe
 				various process-related limits that have
 				one uniform value for any given machine. 
-<li><a accesskey=2 href="#System%20Options">System Options</a>:            Optional POSIX features. 
-<li><a accesskey=3 href="#Version%20Supported">Version Supported</a>:         Version numbers of POSIX.1 and POSIX.2. 
+<li><a accesskey=2 href="#System Options">System Options</a>:            Optional POSIX features. 
+<li><a accesskey=3 href="#Version Supported">Version Supported</a>:         Version numbers of POSIX.1 and POSIX.2. 
 <li><a accesskey=4 href="#Sysconf">Sysconf</a>:                   Getting specific configuration values
                                 of general limits and system options. 
 <li><a accesskey=5 href="#Minimums">Minimums</a>:                  Minimum values for general limits.
 
 <p>
-</p><li><a accesskey=6 href="#Limits%20for%20Files">Limits for Files</a>:          Size limitations that pertain to individual files. 
+</p><li><a accesskey=6 href="#Limits for Files">Limits for Files</a>:          Size limitations that pertain to individual files. 
                                 These can vary between file systems
                                 or even from file to file. 
-<li><a accesskey=7 href="#Options%20for%20Files">Options for Files</a>:         Optional features that some files may support. 
-<li><a accesskey=8 href="#File%20Minimums">File Minimums</a>:             Minimum values for file limits. 
+<li><a accesskey=7 href="#Options for Files">Options for Files</a>:         Optional features that some files may support. 
+<li><a accesskey=8 href="#File Minimums">File Minimums</a>:             Minimum values for file limits. 
 <li><a accesskey=9 href="#Pathconf">Pathconf</a>:                  Getting the limit values for a particular file.
 
 <p>
-</p><li><a href="#Utility%20Limits">Utility Limits</a>:            Capacity limits of some POSIX.2 utility programs. 
-<li><a href="#Utility%20Minimums">Utility Minimums</a>:          Minimum allowable values of those limits.
+</p><li><a href="#Utility Limits">Utility Limits</a>:            Capacity limits of some POSIX.2 utility programs. 
+<li><a href="#Utility Minimums">Utility Minimums</a>:          Minimum allowable values of those limits.
 
 <p>
-</p><li><a href="#String%20Parameters">String Parameters</a>:         Getting the default search path. 
+</p><li><a href="#String Parameters">String Parameters</a>:         Getting the default search path. 
 </ul>
 
 <p><hr>
-Node:<a name="General%20Limits">General Limits</a>,
-Next:<a rel=next accesskey=n href="#System%20Options">System Options</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Node:<a name="General Limits">General Limits</a>,
+Next:<a rel=next accesskey=n href="#System Options">System Options</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>General Capacity Limits</h3>
 
@@ -72959,95 +71417,89 @@
 with <code>_POSIX</code>, which gives the lowest value that the limit is
 allowed to have on <em>any</em> POSIX system.  See <a href="#Minimums">Minimums</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ARG_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>ARG_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined, the unvarying maximum combined length of the <var>argv</var> and
 <var>environ</var> arguments that can be passed to the <code>exec</code> functions. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>CHILD_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>CHILD_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined, the unvarying maximum number of processes that can exist
 with the same real user ID at any one time.  In BSD and GNU, this is
-controlled by the <code>RLIMIT_NPROC</code> resource limit; see <a href="#Limits%20on%20Resources">Limits on Resources</a>. 
+controlled by the <code>RLIMIT_NPROC</code> resource limit; see <a href="#Limits on Resources">Limits on Resources</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>OPEN_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>OPEN_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined, the unvarying maximum number of files that a single process
 can have open simultaneously.  In BSD and GNU, this is controlled
-by the <code>RLIMIT_NOFILE</code> resource limit; see <a href="#Limits%20on%20Resources">Limits on Resources</a>. 
+by the <code>RLIMIT_NOFILE</code> resource limit; see <a href="#Limits on Resources">Limits on Resources</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>STREAM_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>STREAM_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined, the unvarying maximum number of streams that a single
-process can have open simultaneously.  See <a href="#Opening%20Streams">Opening Streams</a>. 
+process can have open simultaneously.  See <a href="#Opening Streams">Opening Streams</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>TZNAME_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>TZNAME_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If defined, the unvarying maximum length of a time zone name. 
-See <a href="#Time%20Zone%20Functions">Time Zone Functions</a>. 
+See <a href="#Time Zone Functions">Time Zone Functions</a>. 
 </td></tr>
 </table>
 
 <p>These limit macros are always defined in <code>limits.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>NGROUPS_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>NGROUPS_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The maximum number of supplementary group IDs that one process can have.
 
 <p>The value of this macro is actually a lower bound for the maximum.  That
@@ -73058,16 +71510,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>SSIZE_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>SSIZE_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest value that can fit in an object of type <code>ssize_t</code>. 
 Effectively, this is the limit on the number of bytes that can be read
 or written in a single operation.
@@ -73077,16 +71528,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>RE_DUP_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>RE_DUP_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest number of repetitions you are guaranteed is allowed in the
 construct <code>\{<var>min</var>,<var>max</var>\}</code> in a regular expression.
 
@@ -73102,12 +71552,12 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="System%20Options">System Options</a>,
-Next:<a rel=next accesskey=n href="#Version%20Supported">Version Supported</a>,
-Previous:<a rel=previous accesskey=p href="#General%20Limits">General Limits</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Node:<a name="System Options">System Options</a>,
+Next:<a rel=next accesskey=n href="#Version Supported">Version Supported</a>,
+Previous:<a rel=previous accesskey=p href="#General Limits">General Limits</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Overall System Options</h3>
 
@@ -73124,40 +71574,38 @@
 then the option is supported.  Otherwise, the option may or may not be
 supported; use <code>sysconf</code> to find out.  See <a href="#Sysconf">Sysconf</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX_JOB_CONTROL</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX_JOB_CONTROL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this symbol is defined, it indicates that the system supports job
 control.  Otherwise, the implementation behaves as if all processes
-within a session belong to a single process group.  See <a href="#Job%20Control">Job Control</a>. 
+within a session belong to a single process group.  See <a href="#Job Control">Job Control</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX_SAVED_IDS</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX_SAVED_IDS</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this symbol is defined, it indicates that the system remembers the
 effective user and group IDs of a process before it executes an
 executable file with the set-user-ID or set-group-ID bits set, and that
 explicitly changing the effective user or group IDs back to these values
 is permitted.  If this option is not defined, then if a nonprivileged
 process changes its effective user or group ID to the real user or group
-ID of the process, it can't change it back again.  See <a href="#Enable%2fDisable%20Setuid">Enable/Disable Setuid</a>. 
+ID of the process, it can't change it back again.  See <a href="#Enable%2fDisable Setuid">Enable/Disable Setuid</a>. 
 </td></tr>
 </table>
 
 <p>For the following macros, if the macro is defined in <code>unistd.h</code>,
@@ -73166,16 +71614,15 @@
 defined, then the option may or may not be supported; use <code>sysconf</code>
 to find out.  See <a href="#Sysconf">Sysconf</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX2_C_DEV</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX2_C_DEV</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this symbol is defined, it indicates that the system has the POSIX.2
 C compiler command, <code>c89</code>.  The GNU C library always defines this
 as <code>1</code>, on the assumption that you would not have installed it if
@@ -73183,64 +71630,60 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX2_FORT_DEV</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX2_FORT_DEV</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this symbol is defined, it indicates that the system has the POSIX.2
 Fortran compiler command, <code>fort77</code>.  The GNU C library never
 defines this, because we don't know what the system has. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX2_FORT_RUN</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX2_FORT_RUN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this symbol is defined, it indicates that the system has the POSIX.2
 <code>asa</code> command to interpret Fortran carriage control.  The GNU C
 library never defines this, because we don't know what the system has. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX2_LOCALEDEF</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX2_LOCALEDEF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this symbol is defined, it indicates that the system has the POSIX.2
 <code>localedef</code> command.  The GNU C library never defines this, because
 we don't know what the system has. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX2_SW_DEV</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX2_SW_DEV</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this symbol is defined, it indicates that the system has the POSIX.2
 commands <code>ar</code>, <code>make</code>, and <code>strip</code>.  The GNU C library
 always defines this as <code>1</code>, on the assumption that you had to have
@@ -73249,25 +71692,24 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Version%20Supported">Version Supported</a>,
+Node:<a name="Version Supported">Version Supported</a>,
 Next:<a rel=next accesskey=n href="#Sysconf">Sysconf</a>,
-Previous:<a rel=previous accesskey=p href="#System%20Options">System Options</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Previous:<a rel=previous accesskey=p href="#System Options">System Options</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Which Version of POSIX is Supported</h3>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>_POSIX_VERSION</b><i>
-</i></td>
+<td align="left"><code>long int <b>_POSIX_VERSION</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant represents the version of the POSIX.1 standard to which
 the implementation conforms.  For an implementation conforming to the
 1995 POSIX.1 standard, the value is the integer <code>199506L</code>.
@@ -73289,16 +71731,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>_POSIX2_C_VERSION</b><i>
-</i></td>
+<td align="left"><code>long int <b>_POSIX2_C_VERSION</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This constant represents the version of the POSIX.2 standard which the
 library and system kernel support.  We don't know what value this will
 be for the first version of the POSIX.2 standard, because the value is
@@ -73316,10 +71757,10 @@
 
 <p><hr>
 Node:<a name="Sysconf">Sysconf</a>,
 Next:<a rel=next accesskey=n href="#Minimums">Minimums</a>,
-Previous:<a rel=previous accesskey=p href="#Version%20Supported">Version Supported</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Previous:<a rel=previous accesskey=p href="#Version Supported">Version Supported</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Using <code>sysconf</code></h3>
 
@@ -73328,31 +71769,30 @@
 particular machine.  The function and the associated <var>parameter</var>
 constants are declared in the header file <code>unistd.h</code>.
 
 <ul>
-<li><a accesskey=1 href="#Sysconf%20Definition">Sysconf Definition</a>:         Detailed specifications of <code>sysconf</code>. 
-<li><a accesskey=2 href="#Constants%20for%20Sysconf">Constants for Sysconf</a>:      The list of parameters <code>sysconf</code> can read. 
-<li><a accesskey=3 href="#Examples%20of%20Sysconf">Examples of Sysconf</a>:        How to use <code>sysconf</code> and the parameter
+<li><a accesskey=1 href="#Sysconf Definition">Sysconf Definition</a>:         Detailed specifications of <code>sysconf</code>. 
+<li><a accesskey=2 href="#Constants for Sysconf">Constants for Sysconf</a>:      The list of parameters <code>sysconf</code> can read. 
+<li><a accesskey=3 href="#Examples of Sysconf">Examples of Sysconf</a>:        How to use <code>sysconf</code> and the parameter
 				 macros properly together. 
 </ul>
 
 <p><hr>
-Node:<a name="Sysconf%20Definition">Sysconf Definition</a>,
-Next:<a rel=next accesskey=n href="#Constants%20for%20Sysconf">Constants for Sysconf</a>,
+Node:<a name="Sysconf Definition">Sysconf Definition</a>,
+Next:<a rel=next accesskey=n href="#Constants for Sysconf">Constants for Sysconf</a>,
 Up:<a rel=up accesskey=u href="#Sysconf">Sysconf</a>
 <br>
 
 <h4>Definition of <code>sysconf</code></h4>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>sysconf</b><i> (int <var>parameter</var>)
-</i></td>
+<td align="left"><code>long int <b>sysconf</b><i> (int <var>parameter</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to inquire about runtime system parameters.  The
 <var>parameter</var> argument should be one of the <code>_SC_</code> symbols listed
 below.
@@ -73370,11 +71810,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Constants%20for%20Sysconf">Constants for Sysconf</a>,
-Next:<a rel=next accesskey=n href="#Examples%20of%20Sysconf">Examples of Sysconf</a>,
-Previous:<a rel=previous accesskey=p href="#Sysconf%20Definition">Sysconf Definition</a>,
+Node:<a name="Constants for Sysconf">Constants for Sysconf</a>,
+Next:<a rel=next accesskey=n href="#Examples of Sysconf">Examples of Sysconf</a>,
+Previous:<a rel=previous accesskey=p href="#Sysconf Definition">Sysconf Definition</a>,
 Up:<a rel=up accesskey=u href="#Sysconf">Sysconf</a>
 <br>
 
 <h4>Constants for <code>sysconf</code> Parameters</h4>
@@ -73412,9 +71852,9 @@
 <dd>Inquire about the parameter corresponding to <code>_POSIX_VERSION</code>.
 
 <br><dt><code>_SC_CLK_TCK</code>
 <dd>Inquire about the parameter corresponding to <code>CLOCKS_PER_SEC</code>;
-see <a href="#CPU%20Time">CPU Time</a>.
+see <a href="#CPU Time">CPU Time</a>.
 
 <br><dt><code>_SC_CHARCLASS_NAME_MAX</code>
 <dd>Inquire about the parameter corresponding to maximal length allowed for
 a character class name in an extended locale specification.  These
@@ -73656,9 +72096,9 @@
 support.
 
 <br><dt><code>_SC_PAGESIZE</code>
 <dd>Inquire about the virtual memory page size of the machine. 
-<code>getpagesize</code> returns the same value (see <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>).
+<code>getpagesize</code> returns the same value (see <a href="#Query Memory Parameters">Query Memory Parameters</a>).
 
 <br><dt><code>_SC_NPROCESSORS_CONF</code>
 <dd>Inquire about the number of configured processors.
 
@@ -73672,9 +72112,9 @@
 <dd>Inquire about the number of available physical pages in the system.
 
 <br><dt><code>_SC_ATEXIT_MAX</code>
 <dd>Inquire about the number of functions which can be registered as termination
-functions for <code>atexit</code>; see <a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>.
+functions for <code>atexit</code>; see <a href="#Cleanups on Exit">Cleanups on Exit</a>.
 
 <br><dt><code>_SC_XOPEN_VERSION</code>
 <dd>Inquire about the parameter corresponding to <code>_XOPEN_VERSION</code>.
 
@@ -73799,10 +72239,10 @@
 <dd>Inquire about the parameter corresponding to <code>NL_TEXTMAX</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Examples%20of%20Sysconf">Examples of Sysconf</a>,
-Previous:<a rel=previous accesskey=p href="#Constants%20for%20Sysconf">Constants for Sysconf</a>,
+Node:<a name="Examples of Sysconf">Examples of Sysconf</a>,
+Previous:<a rel=previous accesskey=p href="#Constants for Sysconf">Constants for Sysconf</a>,
 Up:<a rel=up accesskey=u href="#Sysconf">Sysconf</a>
 <br>
 
 <h4>Examples of <code>sysconf</code></h4>
@@ -73845,11 +72285,11 @@
 </pre>
 
 <p><hr>
 Node:<a name="Minimums">Minimums</a>,
-Next:<a rel=next accesskey=n href="#Limits%20for%20Files">Limits for Files</a>,
+Next:<a rel=next accesskey=n href="#Limits for Files">Limits for Files</a>,
 Previous:<a rel=previous accesskey=p href="#Sysconf">Sysconf</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Minimum Values for General Capacity Limits</h3>
 
@@ -73913,12 +72353,12 @@
 in a regular expression.  Its value is <code>255</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Limits%20for%20Files">Limits for Files</a>,
-Next:<a rel=next accesskey=n href="#Options%20for%20Files">Options for Files</a>,
+Node:<a name="Limits for Files">Limits for Files</a>,
+Next:<a rel=next accesskey=n href="#Options for Files">Options for Files</a>,
 Previous:<a rel=previous accesskey=p href="#Minimums">Minimums</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Limits on File System Capacity</h3>
 
@@ -73937,127 +72377,119 @@
 find out the limit that applies to a particular file.  See <a href="#Pathconf">Pathconf</a>.
 
 <p>Each parameter also has another macro, with a name starting with
 <code>_POSIX</code>, which gives the lowest value that the limit is allowed to
-have on <em>any</em> POSIX system.  See <a href="#File%20Minimums">File Minimums</a>.
+have on <em>any</em> POSIX system.  See <a href="#File Minimums">File Minimums</a>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>LINK_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>LINK_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The uniform system limit (if any) for the number of names for a given
-file.  See <a href="#Hard%20Links">Hard Links</a>. 
+file.  See <a href="#Hard Links">Hard Links</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MAX_CANON</b><i>
-</i></td>
+<td align="left"><code>int <b>MAX_CANON</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The uniform system limit (if any) for the amount of text in a line of
-input when input editing is enabled.  See <a href="#Canonical%20or%20Not">Canonical or Not</a>. 
+input when input editing is enabled.  See <a href="#Canonical or Not">Canonical or Not</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MAX_INPUT</b><i>
-</i></td>
+<td align="left"><code>int <b>MAX_INPUT</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The uniform system limit (if any) for the total number of characters
-typed ahead as input.  See <a href="#I%2fO%20Queues">I/O Queues</a>. 
+typed ahead as input.  See <a href="#I%2fO Queues">I/O Queues</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>NAME_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>NAME_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The uniform system limit (if any) for the length of a file name component. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PATH_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>PATH_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The uniform system limit (if any) for the length of an entire file name (that
 is, the argument given to system calls such as <code>open</code>). 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>PIPE_BUF</b><i>
-</i></td>
+<td align="left"><code>int <b>PIPE_BUF</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The uniform system limit (if any) for the number of bytes that can be
 written atomically to a pipe.  If multiple processes are writing to the
 same pipe simultaneously, output from different processes might be
-interleaved in chunks of this size.  See <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>. 
+interleaved in chunks of this size.  See <a href="#Pipes and FIFOs">Pipes and FIFOs</a>. 
 </td></tr>
 </table>
 
 <p>These are alternative macro names for some of the same information.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>MAXNAMLEN</b><i>
-</i></td>
+<td align="left"><code>int <b>MAXNAMLEN</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the BSD name for <code>NAME_MAX</code>.  It is defined in
 <code>dirent.h</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>FILENAME_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>FILENAME_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The value of this macro is an integer constant expression that
 represents the maximum length of a file name string.  It is defined in
 <code>stdio.h</code>.
@@ -74067,17 +72499,17 @@
 number.  <strong>This is always the case on the GNU system.</strong>
 
 <p><strong>Usage Note:</strong> Don't use <code>FILENAME_MAX</code> as the size of an
 array in which to store a file name!  You can't possibly make an array
-that big!  Use dynamic allocation (see <a href="#Memory%20Allocation">Memory Allocation</a>) instead. 
+that big!  Use dynamic allocation (see <a href="#Memory Allocation">Memory Allocation</a>) instead. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Options%20for%20Files">Options for Files</a>,
-Next:<a rel=next accesskey=n href="#File%20Minimums">File Minimums</a>,
-Previous:<a rel=previous accesskey=p href="#Limits%20for%20Files">Limits for Files</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Node:<a name="Options for Files">Options for Files</a>,
+Next:<a rel=next accesskey=n href="#File Minimums">File Minimums</a>,
+Previous:<a rel=previous accesskey=p href="#Limits for Files">Limits for Files</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Optional Features in File Support</h3>
 
@@ -74101,53 +72533,50 @@
 features.  So these names are never defined as macros in the GNU C
 library.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX_CHOWN_RESTRICTED</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX_CHOWN_RESTRICTED</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this option is in effect, the <code>chown</code> function is restricted so
 that the only changes permitted to nonprivileged processes is to change
 the group owner of a file to either be the effective group ID of the
-process, or one of its supplementary group IDs.  See <a href="#File%20Owner">File Owner</a>. 
+process, or one of its supplementary group IDs.  See <a href="#File Owner">File Owner</a>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>_POSIX_NO_TRUNC</b><i>
-</i></td>
+<td align="left"><code>int <b>_POSIX_NO_TRUNC</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 If this option is in effect, file name components longer than
 <code>NAME_MAX</code> generate an <code>ENAMETOOLONG</code> error.  Otherwise, file
 name components that are too long are silently truncated. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">unsigned char <b>_POSIX_VDISABLE</b><i>
-</i></td>
+<td align="left"><code>unsigned char <b>_POSIX_VDISABLE</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This option is only meaningful for files that are terminal devices. 
 If it is enabled, then handling for special control characters can
-be disabled individually.  See <a href="#Special%20Characters">Special Characters</a>. 
+be disabled individually.  See <a href="#Special Characters">Special Characters</a>. 
 </td></tr>
 </table>
 
 <p>If one of these macros is undefined, that means that the option might be
@@ -74155,12 +72584,12 @@
 particular file, call <code>pathconf</code> or <code>fpathconf</code>. 
 See <a href="#Pathconf">Pathconf</a>.
 
 <p><hr>
-Node:<a name="File%20Minimums">File Minimums</a>,
+Node:<a name="File Minimums">File Minimums</a>,
 Next:<a rel=next accesskey=n href="#Pathconf">Pathconf</a>,
-Previous:<a rel=previous accesskey=p href="#Options%20for%20Files">Options for Files</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Previous:<a rel=previous accesskey=p href="#Options for Files">Options for Files</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Minimum Values for File System Limits</h3>
 
@@ -74185,9 +72614,9 @@
 
 <br><dt><code>_POSIX_MAX_INPUT</code>
 <dd>The most restrictive limit permitted by POSIX for the maximum number of
 bytes in a terminal device input queue (or typeahead buffer). 
-See <a href="#Input%20Modes">Input Modes</a>.  The value of this constant is <code>255</code>.
+See <a href="#Input Modes">Input Modes</a>.  The value of this constant is <code>255</code>.
 
 <br><dt><code>_POSIX_NAME_MAX</code>
 <dd>The most restrictive limit permitted by POSIX for the maximum number of
 bytes in a file name component.  The value of this constant is
@@ -74221,11 +72650,11 @@
 </dl>
 
 <p><hr>
 Node:<a name="Pathconf">Pathconf</a>,
-Next:<a rel=next accesskey=n href="#Utility%20Limits">Utility Limits</a>,
-Previous:<a rel=previous accesskey=p href="#File%20Minimums">File Minimums</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Next:<a rel=next accesskey=n href="#Utility Limits">Utility Limits</a>,
+Previous:<a rel=previous accesskey=p href="#File Minimums">File Minimums</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Using <code>pathconf</code></h3>
 
@@ -74236,16 +72665,15 @@
 <p>These functions and the associated constants for the <var>parameter</var>
 argument are declared in the header file <code>unistd.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>pathconf</b><i> (const char *<var>filename</var>, int <var>parameter</var>)
-</i></td>
+<td align="left"><code>long int <b>pathconf</b><i> (const char *<var>filename</var>, int <var>parameter</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function is used to inquire about the limits that apply to
 the file named <var>filename</var>.
 
@@ -74259,9 +72687,9 @@
 to indicate the cause of the problem.  So the only way to use this
 function robustly is to store <code>0</code> into <code>errno</code> just before
 calling it.
 
-<p>Besides the usual file name errors (see <a href="#File%20Name%20Errors">File Name Errors</a>),
+<p>Besides the usual file name errors (see <a href="#File Name Errors">File Name Errors</a>),
 the following error condition is defined for this function:
 
 <dl>
 <dt><code>EINVAL</code>
@@ -74271,16 +72699,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">long int <b>fpathconf</b><i> (int <var>filedes</var>, int <var>parameter</var>)
-</i></td>
+<td align="left"><code>long int <b>fpathconf</b><i> (int <var>filedes</var>, int <var>parameter</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is just like <code>pathconf</code> except that an open file descriptor
 is used to specify the file for which information is requested, instead
 of a file name.
@@ -74358,12 +72785,12 @@
 <dd>Inquire about the value of <code>POSIX_REC_XFER_ALIGN</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Utility%20Limits">Utility Limits</a>,
-Next:<a rel=next accesskey=n href="#Utility%20Minimums">Utility Minimums</a>,
+Node:<a name="Utility Limits">Utility Limits</a>,
+Next:<a rel=next accesskey=n href="#Utility Minimums">Utility Minimums</a>,
 Previous:<a rel=previous accesskey=p href="#Pathconf">Pathconf</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Utility Program Capacity Limits</h3>
 
@@ -74376,106 +72803,99 @@
 meaningful information.  They are simply the smallest values that
 POSIX.2 permits.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>BC_BASE_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>BC_BASE_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest value of <code>obase</code> that the <code>bc</code> utility is
 guaranteed to support. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>BC_DIM_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>BC_DIM_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest number of elements in one array that the <code>bc</code> utility
 is guaranteed to support. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>BC_SCALE_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>BC_SCALE_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest value of <code>scale</code> that the <code>bc</code> utility is
 guaranteed to support. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>BC_STRING_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>BC_STRING_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest number of characters in one string constant that the
 <code>bc</code> utility is guaranteed to support. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>COLL_WEIGHTS_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>COLL_WEIGHTS_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest number of weights that can necessarily be used in defining
 the collating sequence for a locale. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EXPR_NEST_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>EXPR_NEST_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The maximum number of expressions that can be nested within parenthesis
 by the <code>expr</code> utility. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>LINE_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>LINE_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The largest text line that the text-oriented POSIX.2 utilities can
 support.  (If you are using the GNU versions of these utilities, then
 there is no actual limit except that imposed by the available virtual
@@ -74483,28 +72903,27 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>EQUIV_CLASS_MAX</b><i>
-</i></td>
+<td align="left"><code>int <b>EQUIV_CLASS_MAX</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The maximum number of weights that can be assigned to an entry of the
 <code>LC_COLLATE</code> category <code>order</code> keyword in a locale definition. 
 The GNU C library does not presently support locale definitions. 
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Utility%20Minimums">Utility Minimums</a>,
-Next:<a rel=next accesskey=n href="#String%20Parameters">String Parameters</a>,
-Previous:<a rel=previous accesskey=p href="#Utility%20Limits">Utility Limits</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Node:<a name="Utility Minimums">Utility Minimums</a>,
+Next:<a rel=next accesskey=n href="#String Parameters">String Parameters</a>,
+Previous:<a rel=previous accesskey=p href="#Utility Limits">Utility Limits</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>Minimum Values for Utility Limits</h3>
 
@@ -74548,27 +72967,26 @@
 definitions. 
 </dl>
 
 <p><hr>
-Node:<a name="String%20Parameters">String Parameters</a>,
-Previous:<a rel=previous accesskey=p href="#Utility%20Minimums">Utility Minimums</a>,
-Up:<a rel=up accesskey=u href="#System%20Configuration">System Configuration</a>
+Node:<a name="String Parameters">String Parameters</a>,
+Previous:<a rel=previous accesskey=p href="#Utility Minimums">Utility Minimums</a>,
+Up:<a rel=up accesskey=u href="#System Configuration">System Configuration</a>
 <br>
 
 <h3>String-Valued Parameters</h3>
 
 <p>POSIX.2 defines a way to get string-valued parameters from the operating
 system with the function <code>confstr</code>:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>confstr</b><i> (int <var>parameter</var>, char *<var>buf</var>, size_t <var>len</var>)
-</i></td>
+<td align="left"><code>size_t <b>confstr</b><i> (int <var>parameter</var>, char *<var>buf</var>, size_t <var>len</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This function reads the value of a string-valued system parameter,
 storing the string into <var>len</var> bytes of memory space starting at
 <var>buf</var>.  The <var>parameter</var> argument should be one of the
@@ -74604,44 +73022,44 @@
 
 <br><dt><code>_CS_LFS_CFLAGS</code>
 <dd>The returned string specifies which additional flags must be given to
 the C compiler if a source is compiled using the
-<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_CS_LFS_LDFLAGS</code>
 <dd>The returned string specifies which additional flags must be given to
 the linker if a source is compiled using the
-<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_CS_LFS_LIBS</code>
 <dd>The returned string specifies which additional libraries must be linked
 to the application if a source is compiled using the
-<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_CS_LFS_LINTFLAGS</code>
 <dd>The returned string specifies which additional flags must be given to
 the lint tool if a source is compiled using the
-<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+<code>_LARGEFILE_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_CS_LFS64_CFLAGS</code>
 <dd>The returned string specifies which additional flags must be given to
 the C compiler if a source is compiled using the
-<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_CS_LFS64_LDFLAGS</code>
 <dd>The returned string specifies which additional flags must be given to
 the linker if a source is compiled using the
-<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_CS_LFS64_LIBS</code>
 <dd>The returned string specifies which additional libraries must be linked
 to the application if a source is compiled using the
-<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_CS_LFS64_LINTFLAGS</code>
 <dd>The returned string specifies which additional flags must be given to
 the lint tool if a source is compiled using the
-<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature%20Test%20Macros">Feature Test Macros</a>. 
+<code>_LARGEFILE64_SOURCE</code> feature select macro; see <a href="#Feature Test Macros">Feature Test Macros</a>. 
 </dl>
 
 <p>The way to use <code>confstr</code> without any arbitrary limit on string size
 is to call it twice: first call it to get the length, allocate the
@@ -74664,11 +73082,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Cryptographic%20Functions">Cryptographic Functions</a>,
-Next:<a rel=next accesskey=n href="#Debugging%20Support">Debugging Support</a>,
-Previous:<a rel=previous accesskey=p href="#System%20Configuration">System Configuration</a>,
+Node:<a name="Cryptographic Functions">Cryptographic Functions</a>,
+Next:<a rel=next accesskey=n href="#Debugging Support">Debugging Support</a>,
+Previous:<a rel=previous accesskey=p href="#System Configuration">System Configuration</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>DES Encryption and Password Handling</h2>
@@ -74679,9 +73097,9 @@
 the machine an intruder must have physical access.
 
 <p>Sometimes, however, it is necessary to be sure that a user is authorized
 to use some service a machine provides--for instance, to log in as a
-particular user id (see <a href="#Users%20and%20Groups">Users and Groups</a>).  One traditional way of
+particular user id (see <a href="#Users and Groups">Users and Groups</a>).  One traditional way of
 doing this is for each user to choose a secret <dfn>password</dfn>; then, the
 system can ask someone claiming to be a user what the user's password
 is, and if the person gives the correct password then the system can
 grant the appropriate privileges.
@@ -74699,18 +73117,18 @@
 <p>It also provides support for Secure RPC, and some library functions that
 can be used to perform normal DES encryption.
 
 <ul>
-<li><a accesskey=1 href="#Legal%20Problems">Legal Problems</a>:               This software can get you locked up, or worse. 
+<li><a accesskey=1 href="#Legal Problems">Legal Problems</a>:               This software can get you locked up, or worse. 
 <li><a accesskey=2 href="#getpass">getpass</a>:                      Prompting the user for a password. 
 <li><a accesskey=3 href="#crypt">crypt</a>:                        A one-way function for UNIX passwords. 
-<li><a accesskey=4 href="#DES%20Encryption">DES Encryption</a>:               Routines for DES encryption. 
+<li><a accesskey=4 href="#DES Encryption">DES Encryption</a>:               Routines for DES encryption. 
 </ul>
 
 <p><hr>
-Node:<a name="Legal%20Problems">Legal Problems</a>,
+Node:<a name="Legal Problems">Legal Problems</a>,
 Next:<a rel=next accesskey=n href="#getpass">getpass</a>,
-Up:<a rel=up accesskey=u href="#Cryptographic%20Functions">Cryptographic Functions</a>
+Up:<a rel=up accesskey=u href="#Cryptographic Functions">Cryptographic Functions</a>
 <br>
 
 <h3>Legal Problems</h3>
 
@@ -74750,15 +73168,15 @@
 the source code" to most countries.
 
 <p>The rules in this area are continuously changing.  If you know of any
 information in this manual that is out-of-date, please report it using
-the <code>glibcbug</code> script. See <a href="#Reporting%20Bugs">Reporting Bugs</a>.
+the <code>glibcbug</code> script. See <a href="#Reporting Bugs">Reporting Bugs</a>.
 
 <p><hr>
 Node:<a name="getpass">getpass</a>,
 Next:<a rel=next accesskey=n href="#crypt">crypt</a>,
-Previous:<a rel=previous accesskey=p href="#Legal%20Problems">Legal Problems</a>,
-Up:<a rel=up accesskey=u href="#Cryptographic%20Functions">Cryptographic Functions</a>
+Previous:<a rel=previous accesskey=p href="#Legal Problems">Legal Problems</a>,
+Up:<a rel=up accesskey=u href="#Cryptographic Functions">Cryptographic Functions</a>
 <br>
 
 <h3>Reading Passwords</h3>
 
@@ -74766,24 +73184,23 @@
 the screen, to help keep it secret.  The following function handles this
 in a convenient way.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>getpass</b><i> (const char *<var>prompt</var>)
-</i></td>
+<td align="left"><code>char * <b>getpass</b><i> (const char *<var>prompt</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p><code>getpass</code> outputs <var>prompt</var>, then reads a string in from the
 terminal without echoing it.  It tries to connect to the real terminal,
 <code>/dev/tty</code>, if possible, to encourage users not to put plaintext
 passwords in files; otherwise, it uses <code>stdin</code> and <code>stderr</code>. 
 <code>getpass</code> also disables the INTR, QUIT, and SUSP characters on the
-terminal using the <code>ISIG</code> terminal attribute (see <a href="#Local%20Modes">Local Modes</a>). 
+terminal using the <code>ISIG</code> terminal attribute (see <a href="#Local Modes">Local Modes</a>). 
 The terminal is flushed before and after <code>getpass</code>, so that
 characters of a mistyped password are not accidentally visible.
 
 <p>In other C libraries, <code>getpass</code> may only return the first
@@ -74828,28 +73245,27 @@
 }
 </pre>
 
 <p>The substitute takes the same parameters as <code>getline</code>
-(see <a href="#Line%20Input">Line Input</a>); the user must print any prompt desired.
+(see <a href="#Line Input">Line Input</a>); the user must print any prompt desired.
 
 <p><hr>
 Node:<a name="crypt">crypt</a>,
-Next:<a rel=next accesskey=n href="#DES%20Encryption">DES Encryption</a>,
+Next:<a rel=next accesskey=n href="#DES Encryption">DES Encryption</a>,
 Previous:<a rel=previous accesskey=p href="#getpass">getpass</a>,
-Up:<a rel=up accesskey=u href="#Cryptographic%20Functions">Cryptographic Functions</a>
+Up:<a rel=up accesskey=u href="#Cryptographic Functions">Cryptographic Functions</a>
 <br>
 
 <h3>Encrypting Passwords</h3>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>crypt</b><i> (const char *<var>key</var>, const char *<var>salt</var>)
-</i></td>
+<td align="left"><code>char * <b>crypt</b><i> (const char *<var>key</var>, const char *<var>salt</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>crypt</code> function takes a password, <var>key</var>, as a string, and
 a <var>salt</var> character array which is described below, and returns a
@@ -74919,9 +73335,9 @@
      You should do it better than this... */
   seed[0] = time(NULL);
   seed[1] = getpid() ^ (seed[0] &gt;&gt; 14 &amp; 0x30000);
 
-  /* Turn it into printable characters from `seedchars'. */
+  /* Turn it into printable characters from 'seedchars'. */
   for (i = 0; i &lt; 8; i++)
     salt[3+i] = seedchars[(seed[i/5] &gt;&gt; (i%5)*6) &amp; 0x3f];
 
   /* Read in the user's password and encrypt it. */
@@ -74965,16 +73381,15 @@
 }
 </pre>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char * <b>crypt_r</b><i> (const char *<var>key</var>, const char *<var>salt</var>, struct crypt_data * <var>data</var>)
-</i></td>
+<td align="left"><code>char * <b>crypt_r</b><i> (const char *<var>key</var>, const char *<var>salt</var>, struct crypt_data * <var>data</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>crypt_r</code> function does the same thing as <code>crypt</code>, but
 takes an extra parameter which includes space for its result (among
@@ -74988,11 +73403,11 @@
 <p>The <code>crypt</code> and <code>crypt_r</code> functions are prototyped in the
 header <code>crypt.h</code>.
 
 <p><hr>
-Node:<a name="DES%20Encryption">DES Encryption</a>,
+Node:<a name="DES Encryption">DES Encryption</a>,
 Previous:<a rel=previous accesskey=p href="#crypt">crypt</a>,
-Up:<a rel=up accesskey=u href="#Cryptographic%20Functions">Cryptographic Functions</a>
+Up:<a rel=up accesskey=u href="#Cryptographic Functions">Cryptographic Functions</a>
 <br>
 
 <h3>DES Encryption</h3>
 
@@ -75019,20 +73434,19 @@
 
 <p>Under that numbering, every 8th bit of the key (the 8th, 16th, and so
 on) is not used by the encryption algorithm itself.  But the key must
 have odd parity; that is, out of bits 1 through 8, and 9 through 16, and
-so on, there must be an odd number of `1' bits, and this completely
+so on, there must be an odd number of '1' bits, and this completely
 specifies the unused bits.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setkey</b><i> (const char *<var>key</var>)
-</i></td>
+<td align="left"><code>void <b>setkey</b><i> (const char *<var>key</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>setkey</code> function sets an internal data structure to be an
 expanded form of <var>key</var>.  <var>key</var> is specified as an array of 64
@@ -75042,16 +73456,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>encrypt</b><i> (char *<var>block</var>, int <var>edflag</var>)
-</i></td>
+<td align="left"><code>void <b>encrypt</b><i> (char *<var>block</var>, int <var>edflag</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The <code>encrypt</code> function encrypts <var>block</var> if
 <var>edflag</var> is 0, otherwise it decrypts <var>block</var>, using a key
@@ -75063,25 +73476,24 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>setkey_r</b><i> (const char *<var>key</var>, struct crypt_data * <var>data</var>)
-</i></td>
+<td align="left"><code>void <b>setkey_r</b><i> (const char *<var>key</var>, struct crypt_data * <var>data</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <tr>
-<td align="left">void <b>encrypt_r</b><i> (char *<var>block</var>, int <var>edflag</var>, struct crypt_data * <var>data</var>)
-</i></td>
+<td align="left"><code>void <b>encrypt_r</b><i> (char *<var>block</var>, int <var>edflag</var>, struct crypt_data * <var>data</var>)
+</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>These are reentrant versions of <code>setkey</code> and <code>encrypt</code>.  The
 only difference is the extra parameter, which stores the expanded
@@ -75094,16 +73506,15 @@
 <code>setkey</code>, <code>encrypt</code>, <code>setkey_r</code>, and <code>encrypt_r</code> are
 defined in <code>crypt.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>ecb_crypt</b><i> (char *<var>key</var>, char *<var>blocks</var>, unsigned <var>len</var>, unsigned <var>mode</var>)
-</i></td>
+<td align="left"><code>int <b>ecb_crypt</b><i> (char *<var>key</var>, char *<var>blocks</var>, unsigned <var>len</var>, unsigned <var>mode</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The function <code>ecb_crypt</code> encrypts or decrypts one or more blocks
 using DES.  Each block is encrypted independently.
@@ -75160,31 +73571,29 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>DES_FAILED</b><i> (int <var>err</var>)
-</i></td>
+<td align="left"><code>int <b>DES_FAILED</b><i> (int <var>err</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
-This macro returns 1 if <var>err</var> is a `success' result code from
+This macro returns 1 if <var>err</var> is a 'success' result code from
 <code>ecb_crypt</code> or <code>cbc_crypt</code>, and 0 otherwise. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>cbc_crypt</b><i> (char *<var>key</var>, char *<var>blocks</var>, unsigned <var>len</var>, unsigned <var>mode</var>, char *<var>ivec</var>)
-</i></td>
+<td align="left"><code>int <b>cbc_crypt</b><i> (char *<var>key</var>, char *<var>blocks</var>, unsigned <var>len</var>, unsigned <var>mode</var>, char *<var>ivec</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The function <code>cbc_crypt</code> encrypts or decrypts one or more blocks
 using DES in Cipher Block Chaining mode.
@@ -75209,16 +73618,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>des_setparity</b><i> (char *<var>key</var>)
-</i></td>
+<td align="left"><code>void <b>des_setparity</b><i> (char *<var>key</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 
 <p>The function <code>des_setparity</code> changes the 64-bit <var>key</var>, stored
 packed in 8-bit bytes, to have odd parity by altering the low bits of
@@ -75230,11 +73638,11 @@
 functions and their accompanying macros are all defined in the header
 <code>rpc/des_crypt.h</code>.
 
 <p><hr>
-Node:<a name="Debugging%20Support">Debugging Support</a>,
-Next:<a rel=next accesskey=n href="#Language%20Features">Language Features</a>,
-Previous:<a rel=previous accesskey=p href="#Cryptographic%20Functions">Cryptographic Functions</a>,
+Node:<a name="Debugging Support">Debugging Support</a>,
+Next:<a rel=next accesskey=n href="#Language Features">Language Features</a>,
+Previous:<a rel=previous accesskey=p href="#Cryptographic Functions">Cryptographic Functions</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Debugging support</h2>
@@ -75252,9 +73660,9 @@
 </ul>
 
 <p><hr>
 Node:<a name="Backtraces">Backtraces</a>,
-Up:<a rel=up accesskey=u href="#Debugging%20Support">Debugging Support</a>
+Up:<a rel=up accesskey=u href="#Debugging Support">Debugging Support</a>
 <br>
 
 <h3>Backtraces</h3>
 
@@ -75267,16 +73675,15 @@
 <p>The header file <code>execinfo.h</code> declares three functions that obtain
 and manipulate backtraces of the current thread.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">int <b>backtrace</b><i> (void **<var>buffer</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>int <b>backtrace</b><i> (void **<var>buffer</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>backtrace</code> function obtains a backtrace for the current
 thread, as a list of pointers, and places the information into
 <var>buffer</var>.  The argument <var>size</var> should be the number of
@@ -75295,16 +73702,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">char ** <b>backtrace_symbols</b><i> (void *const *<var>buffer</var>, int <var>size</var>)
-</i></td>
+<td align="left"><code>char ** <b>backtrace_symbols</b><i> (void *const *<var>buffer</var>, int <var>size</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>backtrace_symbols</code> function translates the information
 obtained from the <code>backtrace</code> function into an array of strings. 
 The argument <var>buffer</var> should be a pointer to an array of addresses
@@ -75335,16 +73741,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>backtrace_symbols_fd</b><i> (void *const *<var>buffer</var>, int <var>size</var>, int <var>fd</var>)
-</i></td>
+<td align="left"><code>void <b>backtrace_symbols_fd</b><i> (void *const *<var>buffer</var>, int <var>size</var>, int <var>fd</var>)</i></code></td>
 <td align="right">Function</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>backtrace_symbols_fd</code> function performs the same translation
 as the function <code>backtrace_symbols</code> function.  Instead of returning
 the strings to the caller, it writes the strings to the file descriptor
@@ -75404,11 +73809,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Language%20Features">Language Features</a>,
-Next:<a rel=next accesskey=n href="#Library%20Summary">Library Summary</a>,
-Previous:<a rel=previous accesskey=p href="#Debugging%20Support">Debugging Support</a>,
+Node:<a name="Language Features">Language Features</a>,
+Next:<a rel=next accesskey=n href="#Library Summary">Library Summary</a>,
+Previous:<a rel=previous accesskey=p href="#Debugging Support">Debugging Support</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>C Language Facilities in the Library</h2>
@@ -75419,21 +73824,21 @@
 since we don't have the language manual yet, and documentation for these
 features has been written, we are publishing it here.
 
 <ul>
-<li><a accesskey=1 href="#Consistency%20Checking">Consistency Checking</a>:         Using <code>assert</code> to abort if
-				 something ``impossible'' happens. 
-<li><a accesskey=2 href="#Variadic%20Functions">Variadic Functions</a>:           Defining functions with varying numbers
+<li><a accesskey=1 href="#Consistency Checking">Consistency Checking</a>:         Using <code>assert</code> to abort if
+				 something "impossible" happens. 
+<li><a accesskey=2 href="#Variadic Functions">Variadic Functions</a>:           Defining functions with varying numbers
                                  of args. 
-<li><a accesskey=3 href="#Null%20Pointer%20Constant">Null Pointer Constant</a>:        The macro <code>NULL</code>. 
-<li><a accesskey=4 href="#Important%20Data%20Types">Important Data Types</a>:         Data types for object sizes. 
-<li><a accesskey=5 href="#Data%20Type%20Measurements">Data Type Measurements</a>:       Parameters of data type representations. 
+<li><a accesskey=3 href="#Null Pointer Constant">Null Pointer Constant</a>:        The macro <code>NULL</code>. 
+<li><a accesskey=4 href="#Important Data Types">Important Data Types</a>:         Data types for object sizes. 
+<li><a accesskey=5 href="#Data Type Measurements">Data Type Measurements</a>:       Parameters of data type representations. 
 </ul>
 
 <p><hr>
-Node:<a name="Consistency%20Checking">Consistency Checking</a>,
-Next:<a rel=next accesskey=n href="#Variadic%20Functions">Variadic Functions</a>,
-Up:<a rel=up accesskey=u href="#Language%20Features">Language Features</a>
+Node:<a name="Consistency Checking">Consistency Checking</a>,
+Next:<a rel=next accesskey=n href="#Variadic Functions">Variadic Functions</a>,
+Up:<a rel=up accesskey=u href="#Language Features">Language Features</a>
 <br>
 
 <h3>Explicitly Checking Internal Consistency</h3>
 
@@ -75457,29 +73862,28 @@
 would rather have a program crash, visibly, than have it return nonsense
 without indicating anything might be wrong.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>assert</b><i> (int <var>expression</var>)
-</i></td>
+<td align="left"><code>void <b>assert</b><i> (int <var>expression</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Verify the programmer's belief that <var>expression</var> is nonzero at
 this point in the program.
 
 <p>If <code>NDEBUG</code> is not defined, <code>assert</code> tests the value of
 <var>expression</var>.  If it is false (zero), <code>assert</code> aborts the
-program (see <a href="#Aborting%20a%20Program">Aborting a Program</a>) after printing a message of the
+program (see <a href="#Aborting a Program">Aborting a Program</a>) after printing a message of the
 form:
 
-<br><pre><code><var>file</var></code>:<var>linenum</var>: <var>function</var>: Assertion `<var>expression</var>' failed.
+<br><pre><code><var>file</var></code>:<var>linenum</var>: <var>function</var>: Assertion '<var>expression</var>' failed.
 </pre>
 
-<p>on the standard error stream <code>stderr</code> (see <a href="#Standard%20Streams">Standard Streams</a>). 
+<p>on the standard error stream <code>stderr</code> (see <a href="#Standard Streams">Standard Streams</a>). 
 The filename and line number are taken from the C preprocessor macros
 <code>__FILE__</code> and <code>__LINE__</code> and specify where the call to
 <code>assert</code> was made.  When using the GNU C compiler, the name of
 the function which calls <code>assert</code> is taken from the built-in
@@ -75503,16 +73907,15 @@
 not only where the program crashes, but also what error was returned. 
 The <code>assert_perror</code> macro makes this easy.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>assert_perror</b><i> (int <var>errnum</var>)
-</i></td>
+<td align="left"><code>void <b>assert_perror</b><i> (int <var>errnum</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 Similar to <code>assert</code>, but verifies that <var>errnum</var> is zero.
 
 <p>If <code>NDEBUG</code> is defined, <code>assert_perror</code> tests the value of
@@ -75523,9 +73926,9 @@
 </pre>
 
 <p>on the standard error stream.  The file name, line number, and function
 name are as for <code>assert</code>.  The error text is the result of
-<code>strerror&nbsp;(<var>errnum</var>)</code>.  See <a href="#Error%20Messages">Error Messages</a>.
+<code>strerror&nbsp;(<var>errnum</var>)</code>.  See <a href="#Error Messages">Error Messages</a>.
 
 <p>Like <code>assert</code>, if <code>NDEBUG</code> is defined before <code>assert.h</code>
 is included, the <code>assert_perror</code> macro does absolutely nothing.  It
 does not evaluate the argument, so <var>errnum</var> should not have any side
@@ -75546,19 +73949,19 @@
 track down the cause of a bug, but is not really useful for telling a user
 of your program why his or her input was invalid or why a command could not
 be carried out.  What's more, your program should not abort when given
 invalid input, as <code>assert</code> would do--it should exit with nonzero
-status (see <a href="#Exit%20Status">Exit Status</a>) after printing its error messages, or perhaps
+status (see <a href="#Exit Status">Exit Status</a>) after printing its error messages, or perhaps
 read another command or move on to the next input file.
 
-<p>See <a href="#Error%20Messages">Error Messages</a>, for information on printing error messages for
+<p>See <a href="#Error Messages">Error Messages</a>, for information on printing error messages for
 problems that <em>do not</em> represent bugs in the program.
 
 <p><hr>
-Node:<a name="Variadic%20Functions">Variadic Functions</a>,
-Next:<a rel=next accesskey=n href="#Null%20Pointer%20Constant">Null Pointer Constant</a>,
-Previous:<a rel=previous accesskey=p href="#Consistency%20Checking">Consistency Checking</a>,
-Up:<a rel=up accesskey=u href="#Language%20Features">Language Features</a>
+Node:<a name="Variadic Functions">Variadic Functions</a>,
+Next:<a rel=next accesskey=n href="#Null Pointer Constant">Null Pointer Constant</a>,
+Previous:<a rel=previous accesskey=p href="#Consistency Checking">Consistency Checking</a>,
+Up:<a rel=up accesskey=u href="#Language Features">Language Features</a>
 <br>
 
 <h3>Variadic Functions</h3>
 
@@ -75576,18 +73979,18 @@
 but incompatible, mechanism for defining functions with variable numbers
 of arguments, using <code>varargs.h</code>.
 
 <ul>
-<li><a accesskey=1 href="#Why%20Variadic">Why Variadic</a>:                 Reasons for making functions take
+<li><a accesskey=1 href="#Why Variadic">Why Variadic</a>:                 Reasons for making functions take
                                  variable arguments. 
-<li><a accesskey=2 href="#How%20Variadic">How Variadic</a>:                 How to define and call variadic functions. 
-<li><a accesskey=3 href="#Variadic%20Example">Variadic Example</a>:             A complete example. 
+<li><a accesskey=2 href="#How Variadic">How Variadic</a>:                 How to define and call variadic functions. 
+<li><a accesskey=3 href="#Variadic Example">Variadic Example</a>:             A complete example. 
 </ul>
 
 <p><hr>
-Node:<a name="Why%20Variadic">Why Variadic</a>,
-Next:<a rel=next accesskey=n href="#How%20Variadic">How Variadic</a>,
-Up:<a rel=up accesskey=u href="#Variadic%20Functions">Variadic Functions</a>
+Node:<a name="Why Variadic">Why Variadic</a>,
+Next:<a rel=next accesskey=n href="#How Variadic">How Variadic</a>,
+Up:<a rel=up accesskey=u href="#Variadic Functions">Variadic Functions</a>
 <br>
 
 <h4>Why Variadic Functions are Used</h4>
 
@@ -75609,9 +74012,9 @@
 the length of the array corresponds to that number.  Without facilities
 for variable arguments, you would have to define a separate function for
 each possible array size.
 
-<p>The library function <code>printf</code> (see <a href="#Formatted%20Output">Formatted Output</a>) is an
+<p>The library function <code>printf</code> (see <a href="#Formatted Output">Formatted Output</a>) is an
 example of another class of function where variable arguments are
 useful.  This function prints its arguments (which can vary in type as
 well as number) under the control of a format template string.
 
@@ -75626,12 +74029,12 @@
 <em>declare</em> the function as variadic (or not declare its arguments
 at all!).
 
 <p><hr>
-Node:<a name="How%20Variadic">How Variadic</a>,
-Next:<a rel=next accesskey=n href="#Variadic%20Example">Variadic Example</a>,
-Previous:<a rel=previous accesskey=p href="#Why%20Variadic">Why Variadic</a>,
-Up:<a rel=up accesskey=u href="#Variadic%20Functions">Variadic Functions</a>
+Node:<a name="How Variadic">How Variadic</a>,
+Next:<a rel=next accesskey=n href="#Variadic Example">Variadic Example</a>,
+Previous:<a rel=previous accesskey=p href="#Why Variadic">Why Variadic</a>,
+Up:<a rel=up accesskey=u href="#Variadic Functions">Variadic Functions</a>
 <br>
 
 <h4>How Variadic Functions are Defined and Used</h4>
 
@@ -75639,35 +74042,35 @@
 
 <ul>
 <li><em>Define</em> the function as variadic, using an ellipsis
 (<code><small>...</small></code>) in the argument list, and using special macros to
-access the variable arguments.  See <a href="#Receiving%20Arguments">Receiving Arguments</a>.
+access the variable arguments.  See <a href="#Receiving Arguments">Receiving Arguments</a>.
 
 <li><em>Declare</em> the function as variadic, using a prototype with an
 ellipsis (<code><small>...</small></code>), in all the files which call it. 
-See <a href="#Variadic%20Prototypes">Variadic Prototypes</a>.
+See <a href="#Variadic Prototypes">Variadic Prototypes</a>.
 
 <li><em>Call</em> the function by writing the fixed arguments followed by the
-additional variable arguments.  See <a href="#Calling%20Variadics">Calling Variadics</a>. 
+additional variable arguments.  See <a href="#Calling Variadics">Calling Variadics</a>. 
 </ul>
 
 <ul>
-<li><a accesskey=1 href="#Variadic%20Prototypes">Variadic Prototypes</a>:   How to make a prototype for a function
+<li><a accesskey=1 href="#Variadic Prototypes">Variadic Prototypes</a>:   How to make a prototype for a function
 			  with variable arguments. 
-<li><a accesskey=2 href="#Receiving%20Arguments">Receiving Arguments</a>:   Steps you must follow to access the
+<li><a accesskey=2 href="#Receiving Arguments">Receiving Arguments</a>:   Steps you must follow to access the
 			  optional argument values. 
-<li><a accesskey=3 href="#How%20Many%20Arguments">How Many Arguments</a>:    How to decide whether there are more arguments. 
-<li><a accesskey=4 href="#Calling%20Variadics">Calling Variadics</a>:     Things you need to know about calling
+<li><a accesskey=3 href="#How Many Arguments">How Many Arguments</a>:    How to decide whether there are more arguments. 
+<li><a accesskey=4 href="#Calling Variadics">Calling Variadics</a>:     Things you need to know about calling
 			  variable arguments functions. 
-<li><a accesskey=5 href="#Argument%20Macros">Argument Macros</a>:       Detailed specification of the macros
+<li><a accesskey=5 href="#Argument Macros">Argument Macros</a>:       Detailed specification of the macros
         		  for accessing variable arguments. 
-<li><a accesskey=6 href="#Old%20Varargs">Old Varargs</a>: 		 The pre-ISO way of defining variadic functions. 
+<li><a accesskey=6 href="#Old Varargs">Old Varargs</a>: 		 The pre-ISO way of defining variadic functions. 
 </ul>
 
 <p><hr>
-Node:<a name="Variadic%20Prototypes">Variadic Prototypes</a>,
-Next:<a rel=next accesskey=n href="#Receiving%20Arguments">Receiving Arguments</a>,
-Up:<a rel=up accesskey=u href="#How%20Variadic">How Variadic</a>
+Node:<a name="Variadic Prototypes">Variadic Prototypes</a>,
+Next:<a rel=next accesskey=n href="#Receiving Arguments">Receiving Arguments</a>,
+Up:<a rel=up accesskey=u href="#How Variadic">How Variadic</a>
 <br>
 
 <h5>Syntax for Variable Arguments</h5>
 
@@ -75696,12 +74099,12 @@
 <code>float</code>, <code>char</code> (whether signed or not) and <code>short&nbsp;int</code>
 (whether signed or not).  This is actually an ISO&nbsp;C requirement.
 
 <p><hr>
-Node:<a name="Receiving%20Arguments">Receiving Arguments</a>,
-Next:<a rel=next accesskey=n href="#How%20Many%20Arguments">How Many Arguments</a>,
-Previous:<a rel=previous accesskey=p href="#Variadic%20Prototypes">Variadic Prototypes</a>,
-Up:<a rel=up accesskey=u href="#How%20Variadic">How Variadic</a>
+Node:<a name="Receiving Arguments">Receiving Arguments</a>,
+Next:<a rel=next accesskey=n href="#How Many Arguments">How Many Arguments</a>,
+Previous:<a rel=previous accesskey=p href="#Variadic Prototypes">Variadic Prototypes</a>,
+Up:<a rel=up accesskey=u href="#How Variadic">How Variadic</a>
 <br>
 
 <h5>Receiving the Argument Values</h5>
 
@@ -75735,9 +74138,9 @@
 <code>va_end</code> just in case your program is someday compiled with a peculiar
 compiler.)
 </ol>
 
-<p>See <a href="#Argument%20Macros">Argument Macros</a>, for the full definitions of <code>va_start</code>,
+<p>See <a href="#Argument Macros">Argument Macros</a>, for the full definitions of <code>va_start</code>,
 <code>va_arg</code> and <code>va_end</code>.
 
 <p>Steps 1 and 3 must be performed in the function that accepts the
 optional arguments.  However, you can pass the <code>va_list</code> variable
@@ -75761,12 +74164,12 @@
 an ISO&nbsp;C requirement, but most ANSI C compilers work happily
 regardless.
 
 <p><hr>
-Node:<a name="How%20Many%20Arguments">How Many Arguments</a>,
-Next:<a rel=next accesskey=n href="#Calling%20Variadics">Calling Variadics</a>,
-Previous:<a rel=previous accesskey=p href="#Receiving%20Arguments">Receiving Arguments</a>,
-Up:<a rel=up accesskey=u href="#How%20Variadic">How Variadic</a>
+Node:<a name="How Many Arguments">How Many Arguments</a>,
+Next:<a rel=next accesskey=n href="#Calling Variadics">Calling Variadics</a>,
+Previous:<a rel=previous accesskey=p href="#Receiving Arguments">Receiving Arguments</a>,
+Up:<a rel=up accesskey=u href="#How Variadic">How Variadic</a>
 <br>
 
 <h5>How Many Arguments Were Supplied</h5>
 
@@ -75787,22 +74190,22 @@
 otherwise use a default value.
 
 <p>A required argument can be used as a pattern to specify both the number
 and types of the optional arguments.  The format string argument to
-<code>printf</code> is one example of this (see <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>).
+<code>printf</code> is one example of this (see <a href="#Formatted Output Functions">Formatted Output Functions</a>).
 
 <p>Another possibility is to pass an "end marker" value as the last
 optional argument.  For example, for a function that manipulates an
 arbitrary number of pointer arguments, a null pointer might indicate the
 end of the argument list.  (This assumes that a null pointer isn't
 otherwise meaningful to the function.)  The <code>execl</code> function works
-in just this way; see <a href="#Executing%20a%20File">Executing a File</a>.
+in just this way; see <a href="#Executing a File">Executing a File</a>.
 
 <p><hr>
-Node:<a name="Calling%20Variadics">Calling Variadics</a>,
-Next:<a rel=next accesskey=n href="#Argument%20Macros">Argument Macros</a>,
-Previous:<a rel=previous accesskey=p href="#How%20Many%20Arguments">How Many Arguments</a>,
-Up:<a rel=up accesskey=u href="#How%20Variadic">How Variadic</a>
+Node:<a name="Calling Variadics">Calling Variadics</a>,
+Next:<a rel=next accesskey=n href="#Argument Macros">Argument Macros</a>,
+Previous:<a rel=previous accesskey=p href="#How Many Arguments">How Many Arguments</a>,
+Up:<a rel=up accesskey=u href="#How Variadic">How Variadic</a>
 <br>
 
 <h5>Calling Variadic Functions</h5>
 
@@ -75812,9 +74215,9 @@
 the function with a prototype and know how the argument values are converted.
 
 <p>In principle, functions that are <em>defined</em> to be variadic must also
 be <em>declared</em> to be variadic using a function prototype whenever
-you call them.  (See <a href="#Variadic%20Prototypes">Variadic Prototypes</a>, for how.)  This is because
+you call them.  (See <a href="#Variadic Prototypes">Variadic Prototypes</a>, for how.)  This is because
 some C compilers use a different calling convention to pass the same set
 of argument values to a function depending on whether that function
 takes variable arguments or fixed arguments.
 
@@ -75842,61 +74245,58 @@
 declared argument type as if it were being assigned to a variable of
 that type.
 
 <p><hr>
-Node:<a name="Argument%20Macros">Argument Macros</a>,
-Next:<a rel=next accesskey=n href="#Old%20Varargs">Old Varargs</a>,
-Previous:<a rel=previous accesskey=p href="#Calling%20Variadics">Calling Variadics</a>,
-Up:<a rel=up accesskey=u href="#How%20Variadic">How Variadic</a>
+Node:<a name="Argument Macros">Argument Macros</a>,
+Next:<a rel=next accesskey=n href="#Old Varargs">Old Varargs</a>,
+Previous:<a rel=previous accesskey=p href="#Calling Variadics">Calling Variadics</a>,
+Up:<a rel=up accesskey=u href="#How Variadic">How Variadic</a>
 <br>
 
 <h5>Argument Access Macros</h5>
 
 <p>Here are descriptions of the macros used to retrieve variable arguments. 
 These macros are defined in the header file <code>stdarg.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>va_list</b><i>
-</i></td>
+<td align="left"><code><b>va_list</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The type <code>va_list</code> is used for argument pointer variables. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>va_start</b><i> (va_list <var>ap</var>, <var>last-required</var>)
-</i></td>
+<td align="left"><code>void <b>va_start</b><i> (va_list <var>ap</var>, <var>last-required</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro initializes the argument pointer variable <var>ap</var> to point
 to the first of the optional arguments of the current function;
 <var>last-required</var> must be the last required argument to the function.
 
-<p>See <a href="#Old%20Varargs">Old Varargs</a>, for an alternate definition of <code>va_start</code>
+<p>See <a href="#Old Varargs">Old Varargs</a>, for an alternate definition of <code>va_start</code>
 found in the header file <code>varargs.h</code>. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><var>type</var> <b>va_arg</b><i> (va_list <var>ap</var>, <var>type</var>)
-</i></td>
+<td align="left"><code><var>type</var> <b>va_arg</b><i> (va_list <var>ap</var>, <var>type</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>va_arg</code> macro returns the value of the next optional argument,
 and modifies the value of <var>ap</var> to point to the subsequent argument. 
 Thus, successive uses of <code>va_arg</code> return successive optional
@@ -75909,16 +74309,15 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>va_end</b><i> (va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>void <b>va_end</b><i> (va_list <var>ap</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This ends the use of <var>ap</var>.  After a <code>va_end</code> call, further
 <code>va_arg</code> calls with the same <var>ap</var> may not work.  You should invoke
 <code>va_end</code> before returning from the function in which <code>va_start</code>
@@ -75937,16 +74336,15 @@
 assign the value of one variable of type <code>va_list</code> to another variable
 of the same type.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>__va_copy</b><i> (va_list <var>dest</var>, va_list <var>src</var>)
-</i></td>
+<td align="left"><code>void <b>__va_copy</b><i> (va_list <var>dest</var>, va_list <var>src</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 The <code>__va_copy</code> macro allows copying of objects of type
 <code>va_list</code> even if this is not an integral type.  The argument pointer
 in <var>dest</var> is initialized to point to the same argument as the
@@ -75974,11 +74372,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Variadic%20Example">Variadic Example</a>,
-Previous:<a rel=previous accesskey=p href="#How%20Variadic">How Variadic</a>,
-Up:<a rel=up accesskey=u href="#Variadic%20Functions">Variadic Functions</a>
+Node:<a name="Variadic Example">Variadic Example</a>,
+Previous:<a rel=previous accesskey=p href="#How Variadic">How Variadic</a>,
+Up:<a rel=up accesskey=u href="#Variadic Functions">Variadic Functions</a>
 <br>
 
 <h4>Example of a Variadic Function</h4>
 
@@ -76022,11 +74420,11 @@
 }
 </pre>
 
 <p><hr>
-Node:<a name="Old%20Varargs">Old Varargs</a>,
-Previous:<a rel=previous accesskey=p href="#Argument%20Macros">Argument Macros</a>,
-Up:<a rel=up accesskey=u href="#How%20Variadic">How Variadic</a>
+Node:<a name="Old Varargs">Old Varargs</a>,
+Previous:<a rel=previous accesskey=p href="#Argument Macros">Argument Macros</a>,
+Up:<a rel=up accesskey=u href="#How Variadic">How Variadic</a>
 <br>
 
 <h5>Old-Style Variadic Functions</h5>
 
@@ -76037,9 +74435,9 @@
 old-fashioned variadic facility is called <code>varargs.h</code>.
 
 <p>Using <code>varargs.h</code> is almost the same as using <code>stdarg.h</code>. 
 There is no difference in how you call a variadic function;
-see <a href="#Calling%20Variadics">Calling Variadics</a>.  The only difference is in how you define
+see <a href="#Calling Variadics">Calling Variadics</a>.  The only difference is in how you define
 them.  First of all, you must use old-style non-prototype syntax, like
 this:
 
 <br><pre>tree
@@ -76057,65 +74455,62 @@
 <p>These are the special macros used for defining old-style variadic
 functions:
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>va_alist</b><i>
-</i></td>
+<td align="left"><code><b>va_alist</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro stands for the argument name list required in a variadic
 function. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>va_dcl</b><i>
-</i></td>
+<td align="left"><code><b>va_dcl</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro declares the implicit argument or arguments for a variadic
 function. 
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void <b>va_start</b><i> (va_list <var>ap</var>)
-</i></td>
+<td align="left"><code>void <b>va_start</b><i> (va_list <var>ap</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This macro, as defined in <code>varargs.h</code>, initializes the argument
 pointer variable <var>ap</var> to point to the first argument of the current
 function. 
 </td></tr>
 </table>
 
 <p>The other argument macros, <code>va_arg</code> and <code>va_end</code>, are the same
-in <code>varargs.h</code> as in <code>stdarg.h</code>; see <a href="#Argument%20Macros">Argument Macros</a>, for
+in <code>varargs.h</code> as in <code>stdarg.h</code>; see <a href="#Argument Macros">Argument Macros</a>, for
 details.
 
 <p>It does not work to include both <code>varargs.h</code> and <code>stdarg.h</code> in
 the same compilation; they define <code>va_start</code> in conflicting ways.
 
 <p><hr>
-Node:<a name="Null%20Pointer%20Constant">Null Pointer Constant</a>,
-Next:<a rel=next accesskey=n href="#Important%20Data%20Types">Important Data Types</a>,
-Previous:<a rel=previous accesskey=p href="#Variadic%20Functions">Variadic Functions</a>,
-Up:<a rel=up accesskey=u href="#Language%20Features">Language Features</a>
+Node:<a name="Null Pointer Constant">Null Pointer Constant</a>,
+Next:<a rel=next accesskey=n href="#Important Data Types">Important Data Types</a>,
+Previous:<a rel=previous accesskey=p href="#Variadic Functions">Variadic Functions</a>,
+Up:<a rel=up accesskey=u href="#Language Features">Language Features</a>
 <br>
 
 <h3>Null Pointer Constant</h3>
 
@@ -76124,16 +74519,15 @@
 *</code>.  The preferred way to write a null pointer constant is with
 <code>NULL</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">void * <b>NULL</b><i>
-</i></td>
+<td align="left"><code>void * <b>NULL</b><i></i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is a null pointer constant. 
 </td></tr>
 </table>
@@ -76150,12 +74544,12 @@
 explicitly casting the constant to the proper pointer type, but we
 recommend instead adding a prototype for the function you are calling.
 
 <p><hr>
-Node:<a name="Important%20Data%20Types">Important Data Types</a>,
-Next:<a rel=next accesskey=n href="#Data%20Type%20Measurements">Data Type Measurements</a>,
-Previous:<a rel=previous accesskey=p href="#Null%20Pointer%20Constant">Null Pointer Constant</a>,
-Up:<a rel=up accesskey=u href="#Language%20Features">Language Features</a>
+Node:<a name="Important Data Types">Important Data Types</a>,
+Next:<a rel=next accesskey=n href="#Data Type Measurements">Data Type Measurements</a>,
+Previous:<a rel=previous accesskey=p href="#Null Pointer Constant">Null Pointer Constant</a>,
+Up:<a rel=up accesskey=u href="#Language Features">Language Features</a>
 <br>
 
 <h3>Important Data Types</h3>
 
@@ -76166,16 +74560,15 @@
 them in a portable fashion.  They are defined in the header file
 <code>stddef.h</code>.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>ptrdiff_t</b><i>
-</i></td>
+<td align="left"><code><b>ptrdiff_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is the signed integer type of the result of subtracting two
 pointers.  For example, with the declaration <code>char *p1, *p2;</code>, the
 expression <code>p2 - p1</code> is of type <code>ptrdiff_t</code>.  This will
@@ -76184,21 +74577,20 @@
 </td></tr>
 </table>
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left"><b>size_t</b><i>
-</i></td>
+<td align="left"><code><b>size_t</b><i></i></code></td>
 <td align="right">Data Type</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This is an unsigned integer type used to represent the sizes of objects. 
 The result of the <code>sizeof</code> operator is of this type, and functions
-such as <code>malloc</code> (see <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>) and
-<code>memcpy</code> (see <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>) accept arguments of
+such as <code>malloc</code> (see <a href="#Unconstrained Allocation">Unconstrained Allocation</a>) and
+<code>memcpy</code> (see <a href="#Copying and Concatenation">Copying and Concatenation</a>) accept arguments of
 this type to specify object sizes.
 
 <p><strong>Usage Note:</strong> <code>size_t</code> is the preferred way to declare any
 arguments or variables that hold the size of an object. 
@@ -76227,11 +74619,11 @@
 systems did define <code>size_t</code>, in <code>sys/types.h</code>, but the
 definition was usually a signed type.
 
 <p><hr>
-Node:<a name="Data%20Type%20Measurements">Data Type Measurements</a>,
-Previous:<a rel=previous accesskey=p href="#Important%20Data%20Types">Important Data Types</a>,
-Up:<a rel=up accesskey=u href="#Language%20Features">Language Features</a>
+Node:<a name="Data Type Measurements">Data Type Measurements</a>,
+Previous:<a rel=previous accesskey=p href="#Important Data Types">Important Data Types</a>,
+Up:<a rel=up accesskey=u href="#Language Features">Language Features</a>
 <br>
 
 <h3>Data Type Measurements</h3>
 
@@ -76242,19 +74634,19 @@
 The header files <code>limits.h</code> and <code>float.h</code> contain macros
 which give you this information in full detail.
 
 <ul>
-<li><a accesskey=1 href="#Width%20of%20Type">Width of Type</a>:            How many bits does an integer type hold? 
-<li><a accesskey=2 href="#Range%20of%20Type">Range of Type</a>:            What are the largest and smallest values
+<li><a accesskey=1 href="#Width of Type">Width of Type</a>:            How many bits does an integer type hold? 
+<li><a accesskey=2 href="#Range of Type">Range of Type</a>:            What are the largest and smallest values
 			     that an integer type can hold? 
-<li><a accesskey=3 href="#Floating%20Type%20Macros">Floating Type Macros</a>:     Parameters that measure the floating point types. 
-<li><a accesskey=4 href="#Structure%20Measurement">Structure Measurement</a>:    Getting measurements on structure types. 
+<li><a accesskey=3 href="#Floating Type Macros">Floating Type Macros</a>:     Parameters that measure the floating point types. 
+<li><a accesskey=4 href="#Structure Measurement">Structure Measurement</a>:    Getting measurements on structure types. 
 </ul>
 
 <p><hr>
-Node:<a name="Width%20of%20Type">Width of Type</a>,
-Next:<a rel=next accesskey=n href="#Range%20of%20Type">Range of Type</a>,
-Up:<a rel=up accesskey=u href="#Data%20Type%20Measurements">Data Type Measurements</a>
+Node:<a name="Width of Type">Width of Type</a>,
+Next:<a rel=next accesskey=n href="#Range of Type">Range of Type</a>,
+Up:<a rel=up accesskey=u href="#Data Type Measurements">Data Type Measurements</a>
 <br>
 
 <h4>Computing the Width of an Integer Data Type</h4>
 
@@ -76284,12 +74676,12 @@
 </pre>
 </dl>
 
 <p><hr>
-Node:<a name="Range%20of%20Type">Range of Type</a>,
-Next:<a rel=next accesskey=n href="#Floating%20Type%20Macros">Floating Type Macros</a>,
-Previous:<a rel=previous accesskey=p href="#Width%20of%20Type">Width of Type</a>,
-Up:<a rel=up accesskey=u href="#Data%20Type%20Measurements">Data Type Measurements</a>
+Node:<a name="Range of Type">Range of Type</a>,
+Next:<a rel=next accesskey=n href="#Floating Type Macros">Floating Type Macros</a>,
+Previous:<a rel=previous accesskey=p href="#Width of Type">Width of Type</a>,
+Up:<a rel=up accesskey=u href="#Data Type Measurements">Data Type Measurements</a>
 <br>
 
 <h4>Range of an Integer Type</h4>
 
@@ -76380,20 +74772,20 @@
 
 <br><dt><code>WCHAR_MAX</code>
 <dd>
 This is the maximum value that can be represented by a <code>wchar_t</code>. 
-See <a href="#Extended%20Char%20Intro">Extended Char Intro</a>. 
+See <a href="#Extended Char Intro">Extended Char Intro</a>. 
 </dl>
 
 <p>The header file <code>limits.h</code> also defines some additional constants
 that parameterize various operating system and file system limits.  These
-constants are described in <a href="#System%20Configuration">System Configuration</a>.
+constants are described in <a href="#System Configuration">System Configuration</a>.
 
 <p><hr>
-Node:<a name="Floating%20Type%20Macros">Floating Type Macros</a>,
-Next:<a rel=next accesskey=n href="#Structure%20Measurement">Structure Measurement</a>,
-Previous:<a rel=previous accesskey=p href="#Range%20of%20Type">Range of Type</a>,
-Up:<a rel=up accesskey=u href="#Data%20Type%20Measurements">Data Type Measurements</a>
+Node:<a name="Floating Type Macros">Floating Type Macros</a>,
+Next:<a rel=next accesskey=n href="#Structure Measurement">Structure Measurement</a>,
+Previous:<a rel=previous accesskey=p href="#Range of Type">Range of Type</a>,
+Up:<a rel=up accesskey=u href="#Data Type Measurements">Data Type Measurements</a>
 <br>
 
 <h4>Floating Type Macros</h4>
 
@@ -76404,9 +74796,9 @@
 the machine's floating point representation.
 
 <p>Some of the functions in the C library itself need this information; for
 example, the algorithms for printing and reading floating point numbers
-(see <a href="#I%2fO%20on%20Streams">I/O on Streams</a>) and for calculating trigonometric and
+(see <a href="#I%2fO on Streams">I/O on Streams</a>) and for calculating trigonometric and
 irrational functions (see <a href="#Mathematics">Mathematics</a>) use it to avoid round-off
 error and loss of accuracy.  User programs that implement numerical
 analysis techniques also often need this information in order to
 minimize or compute error bounds.
@@ -76414,18 +74806,18 @@
 <p>The header file <code>float.h</code> describes the format used by your
 machine.
 
 <ul>
-<li><a accesskey=1 href="#Floating%20Point%20Concepts">Floating Point Concepts</a>:      Definitions of terminology. 
-<li><a accesskey=2 href="#Floating%20Point%20Parameters">Floating Point Parameters</a>:    Details of specific macros. 
-<li><a accesskey=3 href="#IEEE%20Floating%20Point">IEEE Floating Point</a>:          The measurements for one common
+<li><a accesskey=1 href="#Floating Point Concepts">Floating Point Concepts</a>:      Definitions of terminology. 
+<li><a accesskey=2 href="#Floating Point Parameters">Floating Point Parameters</a>:    Details of specific macros. 
+<li><a accesskey=3 href="#IEEE Floating Point">IEEE Floating Point</a>:          The measurements for one common
                                  representation. 
 </ul>
 
 <p><hr>
-Node:<a name="Floating%20Point%20Concepts">Floating Point Concepts</a>,
-Next:<a rel=next accesskey=n href="#Floating%20Point%20Parameters">Floating Point Parameters</a>,
-Up:<a rel=up accesskey=u href="#Floating%20Type%20Macros">Floating Type Macros</a>
+Node:<a name="Floating Point Concepts">Floating Point Concepts</a>,
+Next:<a rel=next accesskey=n href="#Floating Point Parameters">Floating Point Parameters</a>,
+Up:<a rel=up accesskey=u href="#Floating Type Macros">Floating Type Macros</a>
 <br>
 
 <h5>Floating Point Representation Concepts</h5>
 
@@ -76502,12 +74894,12 @@
 it is impossible to subtract <code>1</code> from the exponent, so a number
 may be normalized even if its fraction is less than <code>1/<var>b</var></code>.)
 
 <p><hr>
-Node:<a name="Floating%20Point%20Parameters">Floating Point Parameters</a>,
-Next:<a rel=next accesskey=n href="#IEEE%20Floating%20Point">IEEE Floating Point</a>,
-Previous:<a rel=previous accesskey=p href="#Floating%20Point%20Concepts">Floating Point Concepts</a>,
-Up:<a rel=up accesskey=u href="#Floating%20Type%20Macros">Floating Type Macros</a>
+Node:<a name="Floating Point Parameters">Floating Point Parameters</a>,
+Next:<a rel=next accesskey=n href="#IEEE Floating Point">IEEE Floating Point</a>,
+Previous:<a rel=previous accesskey=p href="#Floating Point Concepts">Floating Point Concepts</a>,
+Up:<a rel=up accesskey=u href="#Floating Type Macros">Floating Type Macros</a>
 <br>
 
 <h5>Floating Point Parameters</h5>
 
@@ -76699,11 +75091,11 @@
 supposed to be greater than <code>1E-9</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="IEEE%20Floating%20Point">IEEE Floating Point</a>,
-Previous:<a rel=previous accesskey=p href="#Floating%20Point%20Parameters">Floating Point Parameters</a>,
-Up:<a rel=up accesskey=u href="#Floating%20Type%20Macros">Floating Type Macros</a>
+Node:<a name="IEEE Floating Point">IEEE Floating Point</a>,
+Previous:<a rel=previous accesskey=p href="#Floating Point Parameters">Floating Point Parameters</a>,
+Up:<a rel=up accesskey=u href="#Floating Type Macros">Floating Type Macros</a>
 <br>
 
 <h5>IEEE Floating Point</h5>
 
@@ -76747,27 +75139,26 @@
 DBL_EPSILON     2.2204460492503131E-016
 </pre>
 
 <p><hr>
-Node:<a name="Structure%20Measurement">Structure Measurement</a>,
-Previous:<a rel=previous accesskey=p href="#Floating%20Type%20Macros">Floating Type Macros</a>,
-Up:<a rel=up accesskey=u href="#Data%20Type%20Measurements">Data Type Measurements</a>
+Node:<a name="Structure Measurement">Structure Measurement</a>,
+Previous:<a rel=previous accesskey=p href="#Floating Type Macros">Floating Type Macros</a>,
+Up:<a rel=up accesskey=u href="#Data Type Measurements">Data Type Measurements</a>
 <br>
 
 <h4>Structure Field Offset Measurement</h4>
 
 <p>You can use <code>offsetof</code> to measure the location within a structure
 type of a particular structure member.
 
 <p>
-<table width="100%">
+<table width="70%">
 <tr>
-<td align="left">size_t <b>offsetof</b><i> (<var>type</var>, <var>member</var>)
-</i></td>
+<td align="left"><code>size_t <b>offsetof</b><i> (<var>type</var>, <var>member</var>)</i></code></td>
 <td align="right">Macro</td>
 </tr>
 </table>
-<table width="95%" align="center">
+<table width="65%" align="center">
 <tr><td>
 This expands to a integer constant expression that is the offset of the
 structure member named <var>member</var> in a the structure type <var>type</var>. 
 For example, <code>offsetof (struct s, elem)</code> is the offset, in bytes,
@@ -76778,11 +75169,11 @@
 </td></tr>
 </table>
 
 <p><hr>
-Node:<a name="Library%20Summary">Library Summary</a>,
+Node:<a name="Library Summary">Library Summary</a>,
 Next:<a rel=next accesskey=n href="#Installation">Installation</a>,
-Previous:<a rel=previous accesskey=p href="#Language%20Features">Language Features</a>,
+Previous:<a rel=previous accesskey=p href="#Language Features">Language Features</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Summary of Library Facilities</h2>
@@ -76796,533 +75187,533 @@
 <dl>
 
 <br><dt><code>long int a64l (const char *<var>string</var>)</code>
 <dd>
-<code>stdlib.h</code> (XPG):  <a href="#Encode%20Binary%20Data">Encode Binary Data</a>.
+<code>stdlib.h</code> (XPG):  <a href="#Encode Binary Data">Encode Binary Data</a>.
 
 <br><dt><code>void abort (void)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Aborting%20a%20Program">Aborting a Program</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Aborting a Program">Aborting a Program</a>.
 
 <br><dt><code>int abs (int <var>number</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>int accept (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length_ptr</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Accepting%20Connections">Accepting Connections</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Accepting Connections">Accepting Connections</a>.
 
 <br><dt><code>int access (const char *<var>filename</var>, int <var>how</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Testing%20File%20Access">Testing File Access</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Testing File Access">Testing File Access</a>.
 
 <br><dt><code>ACCOUNTING</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>double acos (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>float acosf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>double acosh (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>float acoshf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double acoshl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double acosl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>int addmntent (FILE *<var>stream</var>, const struct mntent *<var>mnt</var>)</code>
 <dd>
 <code>mntent.h</code> (BSD):  <a href="#mtab">mtab</a>.
 
 <br><dt><code>int adjtime (const struct timeval *<var>delta</var>, struct timeval *<var>olddelta</var>)</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.
+<code>sys/time.h</code> (BSD):  <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.
 
 <br><dt><code>int adjtimex (struct timex *<var>timex</var>)</code>
 <dd>
-<code>sys/timex.h</code> (GNU):  <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.
+<code>sys/timex.h</code> (GNU):  <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.
 
 <br><dt><code>AF_FILE</code>
 <dd>
-<code>sys/socket.h</code> (GNU):  <a href="#Address%20Formats">Address Formats</a>.
+<code>sys/socket.h</code> (GNU):  <a href="#Address Formats">Address Formats</a>.
 
 <br><dt><code>AF_INET</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Address%20Formats">Address Formats</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Address Formats">Address Formats</a>.
 
 <br><dt><code>AF_INET6</code>
 <dd>
-<code>sys/socket.h</code> (IPv6 Basic API):  <a href="#Address%20Formats">Address Formats</a>.
+<code>sys/socket.h</code> (IPv6 Basic API):  <a href="#Address Formats">Address Formats</a>.
 
 <br><dt><code>AF_LOCAL</code>
 <dd>
-<code>sys/socket.h</code> (POSIX):  <a href="#Address%20Formats">Address Formats</a>.
+<code>sys/socket.h</code> (POSIX):  <a href="#Address Formats">Address Formats</a>.
 
 <br><dt><code>AF_UNIX</code>
 <dd>
-<code>sys/socket.h</code> (BSD, Unix98):  <a href="#Address%20Formats">Address Formats</a>.
+<code>sys/socket.h</code> (BSD, Unix98):  <a href="#Address Formats">Address Formats</a>.
 
 <br><dt><code>AF_UNSPEC</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Address%20Formats">Address Formats</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Address Formats">Address Formats</a>.
 
 <br><dt><code>int aio_cancel (int <var>fildes</var>, struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Cancel AIO Operations">Cancel AIO Operations</a>.
 
 <br><dt><code>int aio_cancel64 (int <var>fildes</var>, struct aiocb64 *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>.
+<code>aio.h</code> (Unix98):  <a href="#Cancel AIO Operations">Cancel AIO Operations</a>.
 
 <br><dt><code>int aio_error (const struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Status of AIO Operations">Status of AIO Operations</a>.
 
 <br><dt><code>int aio_error64 (const struct aiocb64 *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>.
+<code>aio.h</code> (Unix98):  <a href="#Status of AIO Operations">Status of AIO Operations</a>.
 
 <br><dt><code>int aio_fsync (int <var>op</var>, struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>.
 
 <br><dt><code>int aio_fsync64 (int <var>op</var>, struct aiocb64 *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>.
+<code>aio.h</code> (Unix98):  <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>.
 
 <br><dt><code>void aio_init (const struct aioinit *<var>init</var>)</code>
 <dd>
-<code>aio.h</code> (GNU):  <a href="#Configuration%20of%20AIO">Configuration of AIO</a>.
+<code>aio.h</code> (GNU):  <a href="#Configuration of AIO">Configuration of AIO</a>.
 
 <br><dt><code>int aio_read (struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>.
 
 <br><dt><code>int aio_read64 (struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>.
+<code>aio.h</code> (Unix98):  <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>.
 
 <br><dt><code>ssize_t aio_return (const struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Status of AIO Operations">Status of AIO Operations</a>.
 
 <br><dt><code>int aio_return64 (const struct aiocb64 *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>.
+<code>aio.h</code> (Unix98):  <a href="#Status of AIO Operations">Status of AIO Operations</a>.
 
 <br><dt><code>int aio_suspend (const struct aiocb *const <var>list</var>[], int <var>nent</var>, const struct timespec *<var>timeout</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>.
 
 <br><dt><code>int aio_suspend64 (const struct aiocb64 *const <var>list</var>[], int <var>nent</var>, const struct timespec *<var>timeout</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>.
+<code>aio.h</code> (Unix98):  <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>.
 
 <br><dt><code>int aio_write (struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>.
 
 <br><dt><code>int aio_write64 (struct aiocb *<var>aiocbp</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>.
+<code>aio.h</code> (Unix98):  <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>.
 
 <br><dt><code>unsigned int alarm (unsigned int <var>seconds</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Setting an Alarm">Setting an Alarm</a>.
 
 <br><dt><code>void * alloca (size_t <var>size</var>);</code>
 <dd>
-<code>stdlib.h</code> (GNU, BSD):  <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>.
+<code>stdlib.h</code> (GNU, BSD):  <a href="#Variable Size Automatic">Variable Size Automatic</a>.
 
 <br><dt><code>int alphasort (const void *<var>a</var>, const void *<var>b</var>)</code>
 <dd>
-<code>dirent.h</code> (BSD/SVID):  <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>.
+<code>dirent.h</code> (BSD/SVID):  <a href="#Scanning Directory Content">Scanning Directory Content</a>.
 
 <br><dt><code>int alphasort64 (const void *<var>a</var>, const void *<var>b</var>)</code>
 <dd>
-<code>dirent.h</code> (GNU):  <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>.
+<code>dirent.h</code> (GNU):  <a href="#Scanning Directory Content">Scanning Directory Content</a>.
 
 <br><dt><code>tcflag_t ALTWERASE</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>int ARG_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>error_t argp_err_exit_status</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Global%20Variables">Argp Global Variables</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Global Variables">Argp Global Variables</a>.
 
 <br><dt><code>void argp_error (const struct argp_state *<var>state</var>, const char *<var>fmt</var>, <small>...</small>)</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Helper Functions">Argp Helper Functions</a>.
 
 <br><dt><code>int ARGP_ERR_UNKNOWN</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Parser Functions">Argp Parser Functions</a>.
 
 <br><dt><code>void argp_failure (const struct argp_state *<var>state</var>, int <var>status</var>, int <var>errnum</var>, const char *<var>fmt</var>, <small>...</small>)</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Helper Functions">Argp Helper Functions</a>.
 
 <br><dt><code>void argp_help (const struct argp *<var>argp</var>, FILE *<var>stream</var>, unsigned <var>flags</var>, char *<var>name</var>)</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Help">Argp Help</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Help">Argp Help</a>.
 
 <br><dt><code>ARGP_IN_ORDER</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>ARGP_KEY_ARG</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_KEY_ARGS</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_KEY_END</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_KEY_ERROR</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_KEY_FINI</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_KEY_HELP_ARGS_DOC</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>.
 
 <br><dt><code>ARGP_KEY_HELP_DUP_ARGS_NOTE</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>.
 
 <br><dt><code>ARGP_KEY_HELP_EXTRA</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>.
 
 <br><dt><code>ARGP_KEY_HELP_HEADER</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>.
 
 <br><dt><code>ARGP_KEY_HELP_POST_DOC</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>.
 
 <br><dt><code>ARGP_KEY_HELP_PRE_DOC</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>.
 
 <br><dt><code>ARGP_KEY_INIT</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_KEY_NO_ARGS</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_KEY_SUCCESS</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Special%20Keys">Argp Special Keys</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Special Keys">Argp Special Keys</a>.
 
 <br><dt><code>ARGP_LONG_ONLY</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>ARGP_NO_ARGS</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>ARGP_NO_ERRS</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>ARGP_NO_EXIT</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>ARGP_NO_HELP</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>error_t argp_parse (const struct argp *<var>argp</var>, int <var>argc</var>, char **<var>argv</var>, unsigned <var>flags</var>, int *<var>arg_index</var>, void *<var>input</var>)</code>
 <dd>
 <code>argp.h</code> (GNU):  <a href="#Argp">Suboptions</a>.
 
 <br><dt><code>ARGP_PARSE_ARGV0</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>const char * argp_program_bug_address</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Global%20Variables">Argp Global Variables</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Global Variables">Argp Global Variables</a>.
 
 <br><dt><code>const char * argp_program_version</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Global%20Variables">Argp Global Variables</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Global Variables">Argp Global Variables</a>.
 
 <br><dt><code>argp_program_version_hook</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Global%20Variables">Argp Global Variables</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Global Variables">Argp Global Variables</a>.
 
 <br><dt><code>ARGP_SILENT</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Flags">Argp Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Flags">Argp Flags</a>.
 
 <br><dt><code>void argp_state_help (const struct argp_state *<var>state</var>, FILE *<var>stream</var>, unsigned <var>flags</var>)</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Helper Functions">Argp Helper Functions</a>.
 
 <br><dt><code>void argp_usage (const struct argp_state *<var>state</var>)</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Helper Functions">Argp Helper Functions</a>.
 
 <br><dt><code>error_t argz_add (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>str</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>error_t argz_add_sep (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>str</var>, int <var>delim</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>error_t argz_append (char **<var>argz</var>, size_t *<var>argz_len</var>, const char *<var>buf</var>, size_t <var>buf_len</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>size_t argz_count (const char *<var>argz</var>, size_t <var>arg_len</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>error_t argz_create (char *const <var>argv</var>[], char **<var>argz</var>, size_t *<var>argz_len</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>error_t argz_create_sep (const char *<var>string</var>, int <var>sep</var>, char **<var>argz</var>, size_t *<var>argz_len</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>error_t argz_delete (char **<var>argz</var>, size_t *<var>argz_len</var>, char *<var>entry</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>void argz_extract (char *<var>argz</var>, size_t <var>argz_len</var>, char **<var>argv</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>error_t argz_insert (char **<var>argz</var>, size_t *<var>argz_len</var>, char *<var>before</var>, const char *<var>entry</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>char * argz_next (char *<var>argz</var>, size_t <var>argz_len</var>, const char *<var>entry</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>error_t argz_replace (char&nbsp;**<var>argz</var>,&nbsp;size_t&nbsp;*<var>argz_len</var>, const&nbsp;char&nbsp;*<var>str</var>,&nbsp;const&nbsp;char&nbsp;*<var>with</var>, unsigned&nbsp;*<var>replace_count</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>void argz_stringify (char *<var>argz</var>, size_t <var>len</var>, int <var>sep</var>)</code>
 <dd>
-<code>argz.h</code> (GNU):  <a href="#Argz%20Functions">Argz Functions</a>.
+<code>argz.h</code> (GNU):  <a href="#Argz Functions">Argz Functions</a>.
 
 <br><dt><code>char * asctime (const struct tm *<var>brokentime</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>.
+<code>time.h</code> (ISO):  <a href="#Formatting Calendar Time">Formatting Calendar Time</a>.
 
 <br><dt><code>char * asctime_r (const struct tm *<var>brokentime</var>, char *<var>buffer</var>)</code>
 <dd>
-<code>time.h</code> (POSIX.1c):  <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>.
+<code>time.h</code> (POSIX.1c):  <a href="#Formatting Calendar Time">Formatting Calendar Time</a>.
 
 <br><dt><code>double asin (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>float asinf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>double asinh (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>float asinhf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double asinhl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double asinl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>int asprintf (char **<var>ptr</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Dynamic%20Output">Dynamic Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Dynamic Output">Dynamic Output</a>.
 
 <br><dt><code>void assert (int <var>expression</var>)</code>
 <dd>
-<code>assert.h</code> (ISO):  <a href="#Consistency%20Checking">Consistency Checking</a>.
+<code>assert.h</code> (ISO):  <a href="#Consistency Checking">Consistency Checking</a>.
 
 <br><dt><code>void assert_perror (int <var>errnum</var>)</code>
 <dd>
-<code>assert.h</code> (GNU):  <a href="#Consistency%20Checking">Consistency Checking</a>.
+<code>assert.h</code> (GNU):  <a href="#Consistency Checking">Consistency Checking</a>.
 
 <br><dt><code>double atan (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>double atan2 (double <var>y</var>, double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>float atan2f (float <var>y</var>, float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>long double atan2l (long double <var>y</var>, long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>float atanf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>double atanh (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>float atanhf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double atanhl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double atanl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>int atexit (void (*<var>function</var>) (void))</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Cleanups on Exit">Cleanups on Exit</a>.
 
 <br><dt><code>double atof (const char *<var>string</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Floats">Parsing of Floats</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Floats">Parsing of Floats</a>.
 
 <br><dt><code>int atoi (const char *<var>string</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>long int atol (const char *<var>string</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>long long int atoll (const char *<var>string</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>B0</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B110</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B115200</code>
 <dd>
-<code>termios.h</code> (GNU):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (GNU):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B1200</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B134</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B150</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B1800</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B19200</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B200</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B230400</code>
 <dd>
-<code>termios.h</code> (GNU):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (GNU):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B2400</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B300</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B38400</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B460800</code>
 <dd>
-<code>termios.h</code> (GNU):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (GNU):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B4800</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B50</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B57600</code>
 <dd>
-<code>termios.h</code> (GNU):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (GNU):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B600</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B75</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>B9600</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>int backtrace (void **<var>buffer</var>, int <var>size</var>)</code>
 <dd>
 <code>execinfo.h</code> (GNU):  <a href="#Backtraces">Backtraces</a>.
@@ -77336,545 +75727,545 @@
 <code>execinfo.h</code> (GNU):  <a href="#Backtraces">Backtraces</a>.
 
 <br><dt><code>char * basename (char *<var>path</var>)</code>
 <dd>
-<code>libgen.h</code> (XPG):  <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>.
+<code>libgen.h</code> (XPG):  <a href="#Finding Tokens in a String">Finding Tokens in a String</a>.
 
 <br><dt><code>char * basename (const char *<var>filename</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>.
+<code>string.h</code> (GNU):  <a href="#Finding Tokens in a String">Finding Tokens in a String</a>.
 
 <br><dt><code>int BC_BASE_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>int BC_DIM_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>int bcmp (const void *<var>a1</var>, const void *<var>a2</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>string.h</code> (BSD):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>void bcopy (const void *<var>from</var>, void *<var>to</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (BSD):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>int BC_SCALE_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>int BC_STRING_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>int bind (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Setting%20Address">Setting Address</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Setting Address">Setting Address</a>.
 
 <br><dt><code>char * bindtextdomain (const char *<var>domainname</var>, const char *<var>dirname</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Locating%20gettext%20catalog">Locating gettext catalog</a>.
+<code>libintl.h</code> (GNU):  <a href="#Locating gettext catalog">Locating gettext catalog</a>.
 
 <br><dt><code>char * bind_textdomain_codeset (const char *<var>domainname</var>, const char *<var>codeset</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Charset%20conversion%20in%20gettext">Charset conversion in gettext</a>.
+<code>libintl.h</code> (GNU):  <a href="#Charset conversion in gettext">Charset conversion in gettext</a>.
 
 <br><dt><code>blkcnt64_t</code>
 <dd>
-<code>sys/types.h</code> (Unix98):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/types.h</code> (Unix98):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>blkcnt_t</code>
 <dd>
-<code>sys/types.h</code> (Unix98):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/types.h</code> (Unix98):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>BOOT_TIME</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>BOOT_TIME</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int brk (void *<var>addr</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>.
+<code>unistd.h</code> (BSD):  <a href="#Resizing the Data Segment">Resizing the Data Segment</a>.
 
 <br><dt><code>tcflag_t BRKINT</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>_BSD_SOURCE</code>
 <dd>
-(GNU):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(GNU):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>void * bsearch (const void *<var>key</var>, const void *<var>array</var>, size_t <var>count</var>, size_t <var>size</var>, comparison_fn_t <var>compare</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Array%20Search%20Function">Array Search Function</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Array Search Function">Array Search Function</a>.
 
 <br><dt><code>wint_t btowc (int <var>c</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Converting%20a%20Character">Converting a Character</a>.
+<code>wchar.h</code> (ISO):  <a href="#Converting a Character">Converting a Character</a>.
 
 <br><dt><code>int BUFSIZ</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (ISO):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>void bzero (void *<var>block</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (BSD):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>double cabs (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>complex.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>float cabsf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>complex.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>long double cabsl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>complex.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>complex double cacos (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>complex float cacosf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>complex double cacosh (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex float cacoshf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double cacoshl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double cacosl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>void * calloc (size_t <var>count</var>, size_t <var>eltsize</var>)</code>
 <dd>
-<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>.
+<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Allocating Cleared Space">Allocating Cleared Space</a>.
 
 <br><dt><code>char * canonicalize_file_name (const char *<var>name</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#Symbolic%20Links">Symbolic Links</a>.
+<code>stdlib.h</code> (GNU):  <a href="#Symbolic Links">Symbolic Links</a>.
 
 <br><dt><code>double carg (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>float cargf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>long double cargl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>complex double casin (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>complex float casinf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>complex double casinh (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex float casinhf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double casinhl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double casinl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>complex double catan (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>complex float catanf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>complex double catanh (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex float catanhf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double catanhl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double catanl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Inverse Trig Functions">Inverse Trig Functions</a>.
 
 <br><dt><code>nl_catd catopen (const char *<var>cat_name</var>, int <var>flag</var>)</code>
 <dd>
-<code>nl_types.h</code> (X/Open):  <a href="#The%20catgets%20Functions">The catgets Functions</a>.
+<code>nl_types.h</code> (X/Open):  <a href="#The catgets Functions">The catgets Functions</a>.
 
 <br><dt><code>int cbc_crypt (char *<var>key</var>, char *<var>blocks</var>, unsigned <var>len</var>, unsigned <var>mode</var>, char *<var>ivec</var>)</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>double cbrt (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (BSD):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float cbrtf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (BSD):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double cbrtl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (BSD):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex double ccos (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>complex float ccosf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>complex double ccosh (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex float ccoshf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double ccoshl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double ccosl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>cc_t</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Data%20Types">Mode Data Types</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Data Types">Mode Data Types</a>.
 
 <br><dt><code>tcflag_t CCTS_OFLOW</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>double ceil (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>float ceilf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long double ceill (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>complex double cexp (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex float cexpf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex long double cexpl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>speed_t cfgetispeed (const struct termios *<var>termios-p</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>speed_t cfgetospeed (const struct termios *<var>termios-p</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>int cfmakeraw (struct termios *<var>termios-p</var>)</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Noncanonical%20Input">Noncanonical Input</a>.
+<code>termios.h</code> (BSD):  <a href="#Noncanonical Input">Noncanonical Input</a>.
 
 <br><dt><code>void cfree (void *<var>ptr</var>)</code>
 <dd>
-<code>stdlib.h</code> (Sun):  <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>.
+<code>stdlib.h</code> (Sun):  <a href="#Freeing after Malloc">Freeing after Malloc</a>.
 
 <br><dt><code>int cfsetispeed (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>int cfsetospeed (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>int cfsetspeed (struct termios *<var>termios-p</var>, speed_t <var>speed</var>)</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (BSD):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>CHAR_BIT</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Width%20of%20Type">Width of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Width of Type">Width of Type</a>.
 
 <br><dt><code>CHAR_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>CHAR_MIN</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>int chdir (const char *<var>filename</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Working%20Directory">Working Directory</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Working Directory">Working Directory</a>.
 
 <br><dt><code>int CHILD_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>int chmod (const char *<var>filename</var>, mode_t <var>mode</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Setting%20Permissions">Setting Permissions</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Setting Permissions">Setting Permissions</a>.
 
 <br><dt><code>int chown (const char *<var>filename</var>, uid_t <var>owner</var>, gid_t <var>group</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#File%20Owner">File Owner</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#File Owner">File Owner</a>.
 
 <br><dt><code>tcflag_t CIGNORE</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>double cimag (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>float cimagf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>long double cimagl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>int clearenv (void)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#Environment%20Access">Environment Access</a>.
+<code>stdlib.h</code> (GNU):  <a href="#Environment Access">Environment Access</a>.
 
 <br><dt><code>void clearerr (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Error%20Recovery">Error Recovery</a>.
+<code>stdio.h</code> (ISO):  <a href="#Error Recovery">Error Recovery</a>.
 
 <br><dt><code>void clearerr_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Error%20Recovery">Error Recovery</a>.
+<code>stdio.h</code> (GNU):  <a href="#Error Recovery">Error Recovery</a>.
 
 <br><dt><code>int CLK_TCK</code>
 <dd>
-<code>time.h</code> (POSIX.1):  <a href="#CPU%20Time">CPU Time</a>.
+<code>time.h</code> (POSIX.1):  <a href="#CPU Time">CPU Time</a>.
 
 <br><dt><code>tcflag_t CLOCAL</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>clock_t clock (void)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#CPU%20Time">CPU Time</a>.
+<code>time.h</code> (ISO):  <a href="#CPU Time">CPU Time</a>.
 
 <br><dt><code>int CLOCKS_PER_SEC</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#CPU%20Time">CPU Time</a>.
+<code>time.h</code> (ISO):  <a href="#CPU Time">CPU Time</a>.
 
 <br><dt><code>clock_t</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#CPU%20Time">CPU Time</a>.
+<code>time.h</code> (ISO):  <a href="#CPU Time">CPU Time</a>.
 
 <br><dt><code>complex double clog (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex double clog10 (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex float clog10f (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex long double clog10l (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex float clogf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex long double clogl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>int close (int <var>filedes</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Opening and Closing Files">Opening and Closing Files</a>.
 
 <br><dt><code>int closedir (DIR *<var>dirstream</var>)</code>
 <dd>
-<code>dirent.h</code> (POSIX.1):  <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>.
+<code>dirent.h</code> (POSIX.1):  <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>.
 
 <br><dt><code>void closelog (void)</code>
 <dd>
 <code>syslog.h</code> (BSD):  <a href="#closelog">closelog</a>.
 
 <br><dt><code>int COLL_WEIGHTS_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>size_t confstr (int <var>parameter</var>, char *<var>buf</var>, size_t <var>len</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>complex double conj (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>complex float conjf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>complex long double conjl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>int connect (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)</code>
 <dd>
 <code>sys/socket.h</code> (BSD):  <a href="#Connecting">Connecting</a>.
 
 <br><dt><code>cookie_close_function</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Hook%20Functions">Hook Functions</a>.
+<code>stdio.h</code> (GNU):  <a href="#Hook Functions">Hook Functions</a>.
 
 <br><dt><code>cookie_io_functions_t</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Streams%20and%20Cookies">Streams and Cookies</a>.
+<code>stdio.h</code> (GNU):  <a href="#Streams and Cookies">Streams and Cookies</a>.
 
 <br><dt><code>cookie_read_function</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Hook%20Functions">Hook Functions</a>.
+<code>stdio.h</code> (GNU):  <a href="#Hook Functions">Hook Functions</a>.
 
 <br><dt><code>cookie_seek_function</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Hook%20Functions">Hook Functions</a>.
+<code>stdio.h</code> (GNU):  <a href="#Hook Functions">Hook Functions</a>.
 
 <br><dt><code>cookie_write_function</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Hook%20Functions">Hook Functions</a>.
+<code>stdio.h</code> (GNU):  <a href="#Hook Functions">Hook Functions</a>.
 
 <br><dt><code>double copysign (double <var>x</var>, double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>float copysignf (float <var>x</var>, float <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>long double copysignl (long double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>double cos (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>float cosf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>double cosh (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>float coshf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double coshl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double cosl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>complex double cpow (complex double <var>base</var>, complex double <var>power</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex float cpowf (complex float <var>base</var>, complex float <var>power</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex long double cpowl (complex long double <var>base</var>, complex long double <var>power</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex double cproj (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>complex float cprojf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>complex long double cprojl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>tcflag_t CREAD</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>double creal (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>float crealf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>long double creall (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Operations%20on%20Complex">Operations on Complex</a>.
+<code>complex.h</code> (ISO):  <a href="#Operations on Complex">Operations on Complex</a>.
 
 <br><dt><code>int creat (const char *<var>filename</var>, mode_t <var>mode</var>)</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Opening and Closing Files">Opening and Closing Files</a>.
 
 <br><dt><code>int creat64 (const char *<var>filename</var>, mode_t <var>mode</var>)</code>
 <dd>
-<code>fcntl.h</code> (Unix98):  <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>.
+<code>fcntl.h</code> (Unix98):  <a href="#Opening and Closing Files">Opening and Closing Files</a>.
 
 <br><dt><code>tcflag_t CRTS_IFLOW</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>char * crypt (const char *<var>key</var>, const char *<var>salt</var>)</code>
 <dd>
 <code>crypt.h</code> (BSD, SVID):  <a href="#crypt">crypt</a>.
@@ -77884,1349 +76275,1349 @@
 <code>crypt.h</code> (GNU):  <a href="#crypt">crypt</a>.
 
 <br><dt><code>tcflag_t CS5</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>tcflag_t CS6</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>tcflag_t CS7</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>tcflag_t CS8</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>complex double csin (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>complex float csinf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>complex double csinh (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex float csinhf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double csinhl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double csinl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>tcflag_t CSIZE</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>_CS_LFS64_CFLAGS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_LFS64_LDFLAGS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_LFS64_LIBS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_LFS64_LINTFLAGS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_LFS_CFLAGS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_LFS_LDFLAGS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_LFS_LIBS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_LFS_LINTFLAGS</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (Unix98):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>_CS_PATH</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#String%20Parameters">String Parameters</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#String Parameters">String Parameters</a>.
 
 <br><dt><code>complex double csqrt (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex float csqrtf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>complex long double csqrtl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>complex.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>tcflag_t CSTOPB</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>complex double ctan (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>complex float ctanf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>complex double ctanh (complex double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex float ctanhf (complex float <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double ctanhl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>complex long double ctanl (complex long double <var>z</var>)</code>
 <dd>
-<code>complex.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>complex.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>char * ctermid (char *<var>string</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX.1):  <a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>.
+<code>stdio.h</code> (POSIX.1):  <a href="#Identifying the Terminal">Identifying the Terminal</a>.
 
 <br><dt><code>char * ctime (const time_t *<var>time</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>.
+<code>time.h</code> (ISO):  <a href="#Formatting Calendar Time">Formatting Calendar Time</a>.
 
 <br><dt><code>char * ctime_r (const time_t *<var>time</var>, char *<var>buffer</var>)</code>
 <dd>
-<code>time.h</code> (POSIX.1c):  <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>.
+<code>time.h</code> (POSIX.1c):  <a href="#Formatting Calendar Time">Formatting Calendar Time</a>.
 
 <br><dt><code>char * cuserid (char *<var>string</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX.1):  <a href="#Who%20Logged%20In">Who Logged In</a>.
+<code>stdio.h</code> (POSIX.1):  <a href="#Who Logged In">Who Logged In</a>.
 
 <br><dt><code>int daylight</code>
 <dd>
-<code>time.h</code> (SVID):  <a href="#Time%20Zone%20Functions">Time Zone Functions</a>.
+<code>time.h</code> (SVID):  <a href="#Time Zone Functions">Time Zone Functions</a>.
 
 <br><dt><code>DBL_DIG</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_EPSILON</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_MANT_DIG</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_MAX</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_MAX_10_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_MAX_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_MIN</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_MIN_10_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>DBL_MIN_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>char * dcgettext (const char *<var>domainname</var>, const char *<var>msgid</var>, int <var>category</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Translation%20with%20gettext">Translation with gettext</a>.
+<code>libintl.h</code> (GNU):  <a href="#Translation with gettext">Translation with gettext</a>.
 
 <br><dt><code>char * dcngettext (const char *<var>domain</var>, const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>, int <var>category</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Advanced%20gettext%20functions">Advanced gettext functions</a>.
+<code>libintl.h</code> (GNU):  <a href="#Advanced gettext functions">Advanced gettext functions</a>.
 
 <br><dt><code>DEAD_PROCESS</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>DEAD_PROCESS</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>DES_DECRYPT</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>DES_ENCRYPT</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>DESERR_BADPARAM</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>DESERR_HWERROR</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>DESERR_NOHWDEVICE</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>DESERR_NONE</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>int DES_FAILED (int <var>err</var>)</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>DES_HW</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>void des_setparity (char *<var>key</var>)</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>DES_SW</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>dev_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>char * dgettext (const char *<var>domainname</var>, const char *<var>msgid</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Translation%20with%20gettext">Translation with gettext</a>.
+<code>libintl.h</code> (GNU):  <a href="#Translation with gettext">Translation with gettext</a>.
 
 <br><dt><code>double difftime (time_t <var>time1</var>, time_t <var>time0</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Elapsed%20Time">Elapsed Time</a>.
+<code>time.h</code> (ISO):  <a href="#Elapsed Time">Elapsed Time</a>.
 
 <br><dt><code>DIR</code>
 <dd>
-<code>dirent.h</code> (POSIX.1):  <a href="#Opening%20a%20Directory">Opening a Directory</a>.
+<code>dirent.h</code> (POSIX.1):  <a href="#Opening a Directory">Opening a Directory</a>.
 
 <br><dt><code>int dirfd (DIR *<var>dirstream</var>)</code>
 <dd>
-<code>dirent.h</code> (GNU):  <a href="#Opening%20a%20Directory">Opening a Directory</a>.
+<code>dirent.h</code> (GNU):  <a href="#Opening a Directory">Opening a Directory</a>.
 
 <br><dt><code>char * dirname (char *<var>path</var>)</code>
 <dd>
-<code>libgen.h</code> (XPG):  <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>.
+<code>libgen.h</code> (XPG):  <a href="#Finding Tokens in a String">Finding Tokens in a String</a>.
 
 <br><dt><code>div_t div (int <var>numerator</var>, int <var>denominator</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>div_t</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>char * dngettext (const char *<var>domain</var>, const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Advanced%20gettext%20functions">Advanced gettext functions</a>.
+<code>libintl.h</code> (GNU):  <a href="#Advanced gettext functions">Advanced gettext functions</a>.
 
 <br><dt><code>double drand48 (void)</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int drand48_r (struct drand48_data *<var>buffer</var>, double *<var>result</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>double drem (double <var>numerator</var>, double <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>float dremf (float <var>numerator</var>, float <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>long double dreml (long double <var>numerator</var>, long double <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>mode_t DTTOIF (int <var>dtype</var>)</code>
 <dd>
-<code>dirent.h</code> (BSD):  <a href="#Directory%20Entries">Directory Entries</a>.
+<code>dirent.h</code> (BSD):  <a href="#Directory Entries">Directory Entries</a>.
 
 <br><dt><code>int dup (int <var>old</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Duplicating Descriptors">Duplicating Descriptors</a>.
 
 <br><dt><code>int dup2 (int <var>old</var>, int <var>new</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Duplicating Descriptors">Duplicating Descriptors</a>.
 
 <br><dt><code>int E2BIG</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Argument list too long):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Argument list too long):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EACCES</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Permission denied):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Permission denied):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EADDRINUSE</code>
 <dd>
-<code>errno.h</code> (BSD: Address already in use):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Address already in use):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EADDRNOTAVAIL</code>
 <dd>
-<code>errno.h</code> (BSD: Cannot assign requested address):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Cannot assign requested address):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EADV</code>
 <dd>
-<code>errno.h</code> (Linux???: Advertise error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Advertise error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EAFNOSUPPORT</code>
 <dd>
-<code>errno.h</code> (BSD: Address family not supported by protocol):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Address family not supported by protocol):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EAGAIN</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Resource temporarily unavailable):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Resource temporarily unavailable):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EALREADY</code>
 <dd>
-<code>errno.h</code> (BSD: Operation already in progress):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Operation already in progress):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EAUTH</code>
 <dd>
-<code>errno.h</code> (BSD: Authentication error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Authentication error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBACKGROUND</code>
 <dd>
-<code>errno.h</code> (GNU: Inappropriate operation for background process):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (GNU: Inappropriate operation for background process):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADE</code>
 <dd>
-<code>errno.h</code> (Linux???: Invalid exchange):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Invalid exchange):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADF</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Bad file descriptor):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Bad file descriptor):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADFD</code>
 <dd>
-<code>errno.h</code> (Linux???: File descriptor in bad state):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: File descriptor in bad state):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADMSG</code>
 <dd>
-<code>errno.h</code> (XOPEN: Bad message):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Bad message):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADR</code>
 <dd>
-<code>errno.h</code> (Linux???: Invalid request descriptor):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Invalid request descriptor):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADRPC</code>
 <dd>
-<code>errno.h</code> (BSD: RPC struct is bad):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: RPC struct is bad):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADRQC</code>
 <dd>
-<code>errno.h</code> (Linux???: Invalid request code):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Invalid request code):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBADSLT</code>
 <dd>
-<code>errno.h</code> (Linux???: Invalid slot):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Invalid slot):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBFONT</code>
 <dd>
-<code>errno.h</code> (Linux???: Bad font file format):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Bad font file format):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EBUSY</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Device or resource busy):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Device or resource busy):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ecb_crypt (char *<var>key</var>, char *<var>blocks</var>, unsigned <var>len</var>, unsigned <var>mode</var>)</code>
 <dd>
-<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>rpc/des_crypt.h</code> (SUNRPC):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>int ECHILD</code>
 <dd>
-<code>errno.h</code> (POSIX.1: No child processes):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: No child processes):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>tcflag_t ECHO</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>tcflag_t ECHOCTL</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>tcflag_t ECHOE</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>tcflag_t ECHOK</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>tcflag_t ECHOKE</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>tcflag_t ECHONL</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>tcflag_t ECHOPRT</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>int ECHRNG</code>
 <dd>
-<code>errno.h</code> (Linux???: Channel number out of range):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Channel number out of range):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ECOMM</code>
 <dd>
-<code>errno.h</code> (Linux???: Communication error on send):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Communication error on send):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ECONNABORTED</code>
 <dd>
-<code>errno.h</code> (BSD: Software caused connection abort):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Software caused connection abort):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ECONNREFUSED</code>
 <dd>
-<code>errno.h</code> (BSD: Connection refused):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Connection refused):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ECONNRESET</code>
 <dd>
-<code>errno.h</code> (BSD: Connection reset by peer):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Connection reset by peer):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>char * ecvt (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</code>
 <dd>
-<code>stdlib.h</code> (SVID, Unix98):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (SVID, Unix98):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>char * ecvt_r (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (GNU):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>int ED</code>
 <dd>
-<code>errno.h</code> (GNU: ?):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (GNU: ?):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EDEADLK</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Resource deadlock avoided):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Resource deadlock avoided):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EDEADLOCK</code>
 <dd>
-<code>errno.h</code> (Linux???: File locking deadlock error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: File locking deadlock error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EDESTADDRREQ</code>
 <dd>
-<code>errno.h</code> (BSD: Destination address required):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Destination address required):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EDIED</code>
 <dd>
-<code>errno.h</code> (GNU: Translator died):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (GNU: Translator died):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EDOM</code>
 <dd>
-<code>errno.h</code> (ISO: Numerical argument out of domain):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (ISO: Numerical argument out of domain):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EDOTDOT</code>
 <dd>
-<code>errno.h</code> (Linux???: RFS specific error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: RFS specific error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EDQUOT</code>
 <dd>
-<code>errno.h</code> (BSD: Disk quota exceeded):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Disk quota exceeded):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EEXIST</code>
 <dd>
-<code>errno.h</code> (POSIX.1: File exists):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: File exists):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EFAULT</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Bad address):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Bad address):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EFBIG</code>
 <dd>
-<code>errno.h</code> (POSIX.1: File too large):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: File too large):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EFTYPE</code>
 <dd>
-<code>errno.h</code> (BSD: Inappropriate file type or format):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Inappropriate file type or format):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EGRATUITOUS</code>
 <dd>
-<code>errno.h</code> (GNU: Gratuitous error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (GNU: Gratuitous error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EGREGIOUS</code>
 <dd>
-<code>errno.h</code> (GNU: You really blew it this time):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (GNU: You really blew it this time):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EHOSTDOWN</code>
 <dd>
-<code>errno.h</code> (BSD: Host is down):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Host is down):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EHOSTUNREACH</code>
 <dd>
-<code>errno.h</code> (BSD: No route to host):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: No route to host):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EIDRM</code>
 <dd>
-<code>errno.h</code> (XOPEN: Identifier removed):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Identifier removed):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EIEIO</code>
 <dd>
-<code>errno.h</code> (GNU: Computer bought the farm):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (GNU: Computer bought the farm):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EILSEQ</code>
 <dd>
-<code>errno.h</code> (ISO: Invalid or incomplete multibyte or wide character):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (ISO: Invalid or incomplete multibyte or wide character):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EINPROGRESS</code>
 <dd>
-<code>errno.h</code> (BSD: Operation now in progress):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Operation now in progress):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EINTR</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Interrupted system call):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Interrupted system call):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EINVAL</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Invalid argument):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Invalid argument):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EIO</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Input/output error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Input/output error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EISCONN</code>
 <dd>
-<code>errno.h</code> (BSD: Transport endpoint is already connected):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Transport endpoint is already connected):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EISDIR</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Is a directory):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Is a directory):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EISNAM</code>
 <dd>
-<code>errno.h</code> (Linux???: Is a named type file):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Is a named type file):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EL2HLT</code>
 <dd>
-<code>errno.h</code> (Obsolete: Level 2 halted):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Obsolete: Level 2 halted):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EL2NSYNC</code>
 <dd>
-<code>errno.h</code> (Obsolete: Level 2 not synchronized):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Obsolete: Level 2 not synchronized):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EL3HLT</code>
 <dd>
-<code>errno.h</code> (Obsolete: Level 3 halted):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Obsolete: Level 3 halted):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EL3RST</code>
 <dd>
-<code>errno.h</code> (Obsolete: Level 3 reset):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Obsolete: Level 3 reset):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ELIBACC</code>
 <dd>
-<code>errno.h</code> (Linux???: Can not access a needed shared library):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Can not access a needed shared library):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ELIBBAD</code>
 <dd>
-<code>errno.h</code> (Linux???: Accessing a corrupted shared library):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Accessing a corrupted shared library):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ELIBEXEC</code>
 <dd>
-<code>errno.h</code> (Linux???: Cannot exec a shared library directly):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Cannot exec a shared library directly):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ELIBMAX</code>
 <dd>
-<code>errno.h</code> (Linux???: Attempting to link in too many shared libraries):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Attempting to link in too many shared libraries):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ELIBSCN</code>
 <dd>
-<code>errno.h</code> (Linux???: .lib section in a.out corrupted):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: .lib section in a.out corrupted):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ELNRNG</code>
 <dd>
-<code>errno.h</code> (Linux???: Link number out of range):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Link number out of range):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ELOOP</code>
 <dd>
-<code>errno.h</code> (BSD: Too many levels of symbolic links):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Too many levels of symbolic links):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EMEDIUMTYPE</code>
 <dd>
-<code>errno.h</code> (Linux???: Wrong medium type):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Wrong medium type):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EMFILE</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Too many open files):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Too many open files):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EMLINK</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Too many links):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Too many links):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>EMPTY</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>EMPTY</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int EMSGSIZE</code>
 <dd>
-<code>errno.h</code> (BSD: Message too long):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Message too long):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EMULTIHOP</code>
 <dd>
-<code>errno.h</code> (XOPEN: Multihop attempted):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Multihop attempted):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENAMETOOLONG</code>
 <dd>
-<code>errno.h</code> (POSIX.1: File name too long):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: File name too long):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENAVAIL</code>
 <dd>
-<code>errno.h</code> (Linux???: No XENIX semaphores available):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: No XENIX semaphores available):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>void encrypt (char *<var>block</var>, int <var>edflag</var>)</code>
 <dd>
-<code>crypt.h</code> (BSD, SVID):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>crypt.h</code> (BSD, SVID):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>void encrypt_r (char *<var>block</var>, int <var>edflag</var>, struct crypt_data * <var>data</var>)</code>
 <dd>
-<code>crypt.h</code> (GNU):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>crypt.h</code> (GNU):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>void endfsent (void)</code>
 <dd>
 <code>fstab.h</code> (BSD):  <a href="#fstab">fstab</a>.
 
 <br><dt><code>void endgrent (void)</code>
 <dd>
-<code>grp.h</code> (SVID, BSD):  <a href="#Scanning%20All%20Groups">Scanning All Groups</a>.
+<code>grp.h</code> (SVID, BSD):  <a href="#Scanning All Groups">Scanning All Groups</a>.
 
 <br><dt><code>void endhostent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>int endmntent (FILE *<var>stream</var>)</code>
 <dd>
 <code>mntent.h</code> (BSD):  <a href="#mtab">mtab</a>.
 
 <br><dt><code>void endnetent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Networks%20Database">Networks Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Networks Database">Networks Database</a>.
 
 <br><dt><code>void endnetgrent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Lookup%20Netgroup">Lookup Netgroup</a>.
+<code>netdb.h</code> (BSD):  <a href="#Lookup Netgroup">Lookup Netgroup</a>.
 
 <br><dt><code>void endprotoent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Protocols%20Database">Protocols Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Protocols Database">Protocols Database</a>.
 
 <br><dt><code>void endpwent (void)</code>
 <dd>
-<code>pwd.h</code> (SVID, BSD):  <a href="#Scanning%20All%20Users">Scanning All Users</a>.
+<code>pwd.h</code> (SVID, BSD):  <a href="#Scanning All Users">Scanning All Users</a>.
 
 <br><dt><code>void endservent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Services%20Database">Services Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Services Database">Services Database</a>.
 
 <br><dt><code>void endutent (void)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>void endutxent (void)</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int ENEEDAUTH</code>
 <dd>
-<code>errno.h</code> (BSD: Need authenticator):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Need authenticator):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENETDOWN</code>
 <dd>
-<code>errno.h</code> (BSD: Network is down):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Network is down):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENETRESET</code>
 <dd>
-<code>errno.h</code> (BSD: Network dropped connection on reset):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Network dropped connection on reset):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENETUNREACH</code>
 <dd>
-<code>errno.h</code> (BSD: Network is unreachable):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Network is unreachable):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENFILE</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Too many open files in system):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Too many open files in system):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOANO</code>
 <dd>
-<code>errno.h</code> (Linux???: No anode):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: No anode):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOBUFS</code>
 <dd>
-<code>errno.h</code> (BSD: No buffer space available):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: No buffer space available):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOCSI</code>
 <dd>
-<code>errno.h</code> (Linux???: No CSI structure available):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: No CSI structure available):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENODATA</code>
 <dd>
-<code>errno.h</code> (XOPEN: No data available):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: No data available):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENODEV</code>
 <dd>
-<code>errno.h</code> (POSIX.1: No such device):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: No such device):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOENT</code>
 <dd>
-<code>errno.h</code> (POSIX.1: No such file or directory):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: No such file or directory):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOEXEC</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Exec format error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Exec format error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOLCK</code>
 <dd>
-<code>errno.h</code> (POSIX.1: No locks available):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: No locks available):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOLINK</code>
 <dd>
-<code>errno.h</code> (XOPEN: Link has been severed):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Link has been severed):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOMEDIUM</code>
 <dd>
-<code>errno.h</code> (Linux???: No medium found):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: No medium found):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOMEM</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Cannot allocate memory):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Cannot allocate memory):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOMSG</code>
 <dd>
-<code>errno.h</code> (XOPEN: No message of desired type):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: No message of desired type):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENONET</code>
 <dd>
-<code>errno.h</code> (Linux???: Machine is not on the network):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Machine is not on the network):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOPKG</code>
 <dd>
-<code>errno.h</code> (Linux???: Package not installed):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Package not installed):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOPROTOOPT</code>
 <dd>
-<code>errno.h</code> (BSD: Protocol not available):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Protocol not available):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOSPC</code>
 <dd>
-<code>errno.h</code> (POSIX.1: No space left on device):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: No space left on device):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOSR</code>
 <dd>
-<code>errno.h</code> (XOPEN: Out of streams resources):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Out of streams resources):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOSTR</code>
 <dd>
-<code>errno.h</code> (XOPEN: Device not a stream):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Device not a stream):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOSYS</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Function not implemented):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Function not implemented):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTBLK</code>
 <dd>
-<code>errno.h</code> (BSD: Block device required):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Block device required):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTCONN</code>
 <dd>
-<code>errno.h</code> (BSD: Transport endpoint is not connected):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Transport endpoint is not connected):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTDIR</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Not a directory):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Not a directory):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTEMPTY</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Directory not empty):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Directory not empty):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTNAM</code>
 <dd>
-<code>errno.h</code> (Linux???: Not a XENIX named type file):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Not a XENIX named type file):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTSOCK</code>
 <dd>
-<code>errno.h</code> (BSD: Socket operation on non-socket):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Socket operation on non-socket):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTSUP</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Not supported):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Not supported):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTTY</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Inappropriate ioctl for device):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Inappropriate ioctl for device):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ENOTUNIQ</code>
 <dd>
-<code>errno.h</code> (Linux???: Name not unique on network):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Name not unique on network):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>char ** environ</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Environment%20Access">Environment Access</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Environment Access">Environment Access</a>.
 
 <br><dt><code>error_t envz_add (char **<var>envz</var>, size_t *<var>envz_len</var>, const char *<var>name</var>, const char *<var>value</var>)</code>
 <dd>
-<code>envz.h</code> (GNU):  <a href="#Envz%20Functions">Envz Functions</a>.
+<code>envz.h</code> (GNU):  <a href="#Envz Functions">Envz Functions</a>.
 
 <br><dt><code>char * envz_entry (const char *<var>envz</var>, size_t <var>envz_len</var>, const char *<var>name</var>)</code>
 <dd>
-<code>envz.h</code> (GNU):  <a href="#Envz%20Functions">Envz Functions</a>.
+<code>envz.h</code> (GNU):  <a href="#Envz Functions">Envz Functions</a>.
 
 <br><dt><code>char * envz_get (const char *<var>envz</var>, size_t <var>envz_len</var>, const char *<var>name</var>)</code>
 <dd>
-<code>envz.h</code> (GNU):  <a href="#Envz%20Functions">Envz Functions</a>.
+<code>envz.h</code> (GNU):  <a href="#Envz Functions">Envz Functions</a>.
 
 <br><dt><code>error_t envz_merge (char **<var>envz</var>, size_t *<var>envz_len</var>, const char *<var>envz2</var>, size_t <var>envz2_len</var>, int <var>override</var>)</code>
 <dd>
-<code>envz.h</code> (GNU):  <a href="#Envz%20Functions">Envz Functions</a>.
+<code>envz.h</code> (GNU):  <a href="#Envz Functions">Envz Functions</a>.
 
 <br><dt><code>void envz_strip (char **<var>envz</var>, size_t *<var>envz_len</var>)</code>
 <dd>
-<code>envz.h</code> (GNU):  <a href="#Envz%20Functions">Envz Functions</a>.
+<code>envz.h</code> (GNU):  <a href="#Envz Functions">Envz Functions</a>.
 
 <br><dt><code>int ENXIO</code>
 <dd>
-<code>errno.h</code> (POSIX.1: No such device or address):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: No such device or address):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EOF</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#EOF%20and%20Errors">EOF and Errors</a>.
+<code>stdio.h</code> (ISO):  <a href="#EOF and Errors">EOF and Errors</a>.
 
 <br><dt><code>int EOPNOTSUPP</code>
 <dd>
-<code>errno.h</code> (BSD: Operation not supported):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Operation not supported):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EOVERFLOW</code>
 <dd>
-<code>errno.h</code> (XOPEN: Value too large for defined data type):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Value too large for defined data type):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPERM</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Operation not permitted):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Operation not permitted):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPFNOSUPPORT</code>
 <dd>
-<code>errno.h</code> (BSD: Protocol family not supported):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Protocol family not supported):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPIPE</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Broken pipe):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Broken pipe):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPROCLIM</code>
 <dd>
-<code>errno.h</code> (BSD: Too many processes):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Too many processes):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPROCUNAVAIL</code>
 <dd>
-<code>errno.h</code> (BSD: RPC bad procedure for program):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: RPC bad procedure for program):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPROGMISMATCH</code>
 <dd>
-<code>errno.h</code> (BSD: RPC program version wrong):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: RPC program version wrong):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPROGUNAVAIL</code>
 <dd>
-<code>errno.h</code> (BSD: RPC program not available):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: RPC program not available):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPROTO</code>
 <dd>
-<code>errno.h</code> (XOPEN: Protocol error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Protocol error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPROTONOSUPPORT</code>
 <dd>
-<code>errno.h</code> (BSD: Protocol not supported):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Protocol not supported):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EPROTOTYPE</code>
 <dd>
-<code>errno.h</code> (BSD: Protocol wrong type for socket):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Protocol wrong type for socket):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EQUIV_CLASS_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>double erand48 (unsigned short int <var>xsubi</var>[3])</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int erand48_r (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, double *<var>result</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int ERANGE</code>
 <dd>
-<code>errno.h</code> (ISO: Numerical result out of range):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (ISO: Numerical result out of range):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EREMCHG</code>
 <dd>
-<code>errno.h</code> (Linux???: Remote address changed):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Remote address changed):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EREMOTE</code>
 <dd>
-<code>errno.h</code> (BSD: Object is remote):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Object is remote):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EREMOTEIO</code>
 <dd>
-<code>errno.h</code> (Linux???: Remote I/O error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Remote I/O error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ERESTART</code>
 <dd>
-<code>errno.h</code> (Linux???: Interrupted system call should be restarted):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Interrupted system call should be restarted):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>double erf (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>double erfc (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float erfcf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double erfcl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float erff (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double erfl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>int EROFS</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Read-only file system):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Read-only file system):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ERPCMISMATCH</code>
 <dd>
-<code>errno.h</code> (BSD: RPC version wrong):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: RPC version wrong):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>void err (int <var>status</var>, const char *<var>format</var>, <small>...</small>)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>volatile int errno</code>
 <dd>
-<code>errno.h</code> (ISO):  <a href="#Checking%20for%20Errors">Checking for Errors</a>.
+<code>errno.h</code> (ISO):  <a href="#Checking for Errors">Checking for Errors</a>.
 
 <br><dt><code>void error (int <var>status</var>, int <var>errnum</var>, const char *<var>format</var>, <small>...</small>)</code>
 <dd>
-<code>error.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>error.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>void error_at_line (int <var>status</var>, int <var>errnum</var>, const char *<var>fname</var>, unsigned int <var>lineno</var>, const char *<var>format</var>, <small>...</small>)</code>
 <dd>
-<code>error.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>error.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>unsigned int error_message_count</code>
 <dd>
-<code>error.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>error.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>int error_one_per_line</code>
 <dd>
-<code>error.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>error.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>void (* error_print_progname ) (void)</code>
 <dd>
-<code>error.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>error.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>void errx (int <var>status</var>, const char *<var>format</var>, <small>...</small>)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>int ESHUTDOWN</code>
 <dd>
-<code>errno.h</code> (BSD: Cannot send after transport endpoint shutdown):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Cannot send after transport endpoint shutdown):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ESOCKTNOSUPPORT</code>
 <dd>
-<code>errno.h</code> (BSD: Socket type not supported):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Socket type not supported):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ESPIPE</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Illegal seek):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Illegal seek):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ESRCH</code>
 <dd>
-<code>errno.h</code> (POSIX.1: No such process):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: No such process):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ESRMNT</code>
 <dd>
-<code>errno.h</code> (Linux???: Srmount error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Srmount error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ESTALE</code>
 <dd>
-<code>errno.h</code> (BSD: Stale NFS file handle):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Stale NFS file handle):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ESTRPIPE</code>
 <dd>
-<code>errno.h</code> (Linux???: Streams pipe error):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Streams pipe error):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ETIME</code>
 <dd>
-<code>errno.h</code> (XOPEN: Timer expired):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (XOPEN: Timer expired):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ETIMEDOUT</code>
 <dd>
-<code>errno.h</code> (BSD: Connection timed out):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Connection timed out):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ETOOMANYREFS</code>
 <dd>
-<code>errno.h</code> (BSD: Too many references: cannot splice):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Too many references: cannot splice):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int ETXTBSY</code>
 <dd>
-<code>errno.h</code> (BSD: Text file busy):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Text file busy):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EUCLEAN</code>
 <dd>
-<code>errno.h</code> (Linux???: Structure needs cleaning):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Structure needs cleaning):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EUNATCH</code>
 <dd>
-<code>errno.h</code> (Linux???: Protocol driver not attached):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Protocol driver not attached):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EUSERS</code>
 <dd>
-<code>errno.h</code> (BSD: Too many users):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Too many users):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EWOULDBLOCK</code>
 <dd>
-<code>errno.h</code> (BSD: Operation would block):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (BSD: Operation would block):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int EXDEV</code>
 <dd>
-<code>errno.h</code> (POSIX.1: Invalid cross-device link):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (POSIX.1: Invalid cross-device link):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>int execl (const char *<var>filename</var>, const char *<var>arg0</var>, <small>...</small>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Executing%20a%20File">Executing a File</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Executing a File">Executing a File</a>.
 
 <br><dt><code>int execle (const char *<var>filename</var>, const char *<var>arg0</var>, char *const <var>env</var><tt>[]</tt>, <small>...</small>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Executing%20a%20File">Executing a File</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Executing a File">Executing a File</a>.
 
 <br><dt><code>int execlp (const char *<var>filename</var>, const char *<var>arg0</var>, <small>...</small>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Executing%20a%20File">Executing a File</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Executing a File">Executing a File</a>.
 
 <br><dt><code>int execv (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Executing%20a%20File">Executing a File</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Executing a File">Executing a File</a>.
 
 <br><dt><code>int execve (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>, char *const <var>env</var><tt>[]</tt>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Executing%20a%20File">Executing a File</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Executing a File">Executing a File</a>.
 
 <br><dt><code>int execvp (const char *<var>filename</var>, char *const <var>argv</var><tt>[]</tt>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Executing%20a%20File">Executing a File</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Executing a File">Executing a File</a>.
 
 <br><dt><code>int EXFULL</code>
 <dd>
-<code>errno.h</code> (Linux???: Exchange full):  <a href="#Error%20Codes">Error Codes</a>.
+<code>errno.h</code> (Linux???: Exchange full):  <a href="#Error Codes">Error Codes</a>.
 
 <br><dt><code>void _Exit (int <var>status</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Termination%20Internals">Termination Internals</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Termination Internals">Termination Internals</a>.
 
 <br><dt><code>void _exit (int <var>status</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Termination%20Internals">Termination Internals</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Termination Internals">Termination Internals</a>.
 
 <br><dt><code>void exit (int <var>status</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Normal%20Termination">Normal Termination</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Normal Termination">Normal Termination</a>.
 
 <br><dt><code>int EXIT_FAILURE</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Exit%20Status">Exit Status</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Exit Status">Exit Status</a>.
 
 <br><dt><code>int EXIT_SUCCESS</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Exit%20Status">Exit Status</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Exit Status">Exit Status</a>.
 
 <br><dt><code>double exp (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double exp10 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float exp10f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double exp10l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double exp2 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float exp2f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double exp2l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float expf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double expl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double expm1 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float expm1f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double expm1l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>int EXPR_NEST_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>double fabs (double <var>number</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>math.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>float fabsf (float <var>number</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>math.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>long double fabsl (long double <var>number</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>math.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>size_t __fbufsize (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>int fchdir (int <var>filedes</var>)</code>
 <dd>
-<code>unistd.h</code> (XPG):  <a href="#Working%20Directory">Working Directory</a>.
+<code>unistd.h</code> (XPG):  <a href="#Working Directory">Working Directory</a>.
 
 <br><dt><code>int fchmod (int <var>filedes</var>, int <var>mode</var>)</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Setting%20Permissions">Setting Permissions</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Setting Permissions">Setting Permissions</a>.
 
 <br><dt><code>int fchown (int <var>filedes</var>, int <var>owner</var>, int <var>group</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#File%20Owner">File Owner</a>.
+<code>unistd.h</code> (BSD):  <a href="#File Owner">File Owner</a>.
 
 <br><dt><code>int fclean (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Cleaning%20Streams">Cleaning Streams</a>.
+<code>stdio.h</code> (GNU):  <a href="#Cleaning Streams">Cleaning Streams</a>.
 
 <br><dt><code>int fclose (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Closing%20Streams">Closing Streams</a>.
+<code>stdio.h</code> (ISO):  <a href="#Closing Streams">Closing Streams</a>.
 
 <br><dt><code>int fcloseall (void)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Closing%20Streams">Closing Streams</a>.
+<code>stdio.h</code> (GNU):  <a href="#Closing Streams">Closing Streams</a>.
 
 <br><dt><code>int fcntl (int <var>filedes</var>, int <var>command</var>, <small>...</small>)</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Control%20Operations">Control Operations</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Control Operations">Control Operations</a>.
 
 <br><dt><code>char * fcvt (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</code>
 <dd>
-<code>stdlib.h</code> (SVID, Unix98):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (SVID, Unix98):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>char * fcvt_r (double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</code>
 <dd>
-<code>stdlib.h</code> (SVID, Unix98):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (SVID, Unix98):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>int fdatasync (int <var>fildes</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX):  <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>.
+<code>unistd.h</code> (POSIX):  <a href="#Synchronizing I%2fO">Synchronizing I/O</a>.
 
 <br><dt><code>int FD_CLOEXEC</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Descriptor%20Flags">Descriptor Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Descriptor Flags">Descriptor Flags</a>.
 
 <br><dt><code>void FD_CLR (int <var>filedes</var>, fd_set *<var>set</var>)</code>
 <dd>
-<code>sys/types.h</code> (BSD):  <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+<code>sys/types.h</code> (BSD):  <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <br><dt><code>double fdim (double <var>x</var>, double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>float fdimf (float <var>x</var>, float <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>long double fdiml (long double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>int FD_ISSET (int <var>filedes</var>, fd_set *<var>set</var>)</code>
 <dd>
-<code>sys/types.h</code> (BSD):  <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+<code>sys/types.h</code> (BSD):  <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <br><dt><code>FILE * fdopen (int <var>filedes</var>, const char *<var>opentype</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX.1):  <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>.
+<code>stdio.h</code> (POSIX.1):  <a href="#Descriptors and Streams">Descriptors and Streams</a>.
 
 <br><dt><code>void FD_SET (int <var>filedes</var>, fd_set *<var>set</var>)</code>
 <dd>
-<code>sys/types.h</code> (BSD):  <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+<code>sys/types.h</code> (BSD):  <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <br><dt><code>fd_set</code>
 <dd>
-<code>sys/types.h</code> (BSD):  <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+<code>sys/types.h</code> (BSD):  <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <br><dt><code>int FD_SETSIZE</code>
 <dd>
-<code>sys/types.h</code> (BSD):  <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+<code>sys/types.h</code> (BSD):  <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <br><dt><code>int F_DUPFD</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Duplicating Descriptors">Duplicating Descriptors</a>.
 
 <br><dt><code>void FD_ZERO (fd_set *<var>set</var>)</code>
 <dd>
-<code>sys/types.h</code> (BSD):  <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+<code>sys/types.h</code> (BSD):  <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <br><dt><code>int feclearexcept (int <var>excepts</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>int fedisableexcept (int <var>excepts</var>)</code>
 <dd>
-<code>fenv.h</code> (GNU):  <a href="#Control%20Functions">Control Functions</a>.
+<code>fenv.h</code> (GNU):  <a href="#Control Functions">Control Functions</a>.
 
 <br><dt><code>FE_DIVBYZERO</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>FE_DOWNWARD</code>
 <dd>
 <code>fenv.h</code> (ISO):  <a href="#Rounding">Rounding</a>.
 
 <br><dt><code>int feenableexcept (int <var>excepts</var>)</code>
 <dd>
-<code>fenv.h</code> (GNU):  <a href="#Control%20Functions">Control Functions</a>.
+<code>fenv.h</code> (GNU):  <a href="#Control Functions">Control Functions</a>.
 
 <br><dt><code>int fegetenv (fenv_t *<var>envp</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Control%20Functions">Control Functions</a>.
+<code>fenv.h</code> (ISO):  <a href="#Control Functions">Control Functions</a>.
 
 <br><dt><code>int fegetexcept (int <var>excepts</var>)</code>
 <dd>
-<code>fenv.h</code> (GNU):  <a href="#Control%20Functions">Control Functions</a>.
+<code>fenv.h</code> (GNU):  <a href="#Control Functions">Control Functions</a>.
 
 <br><dt><code>int fegetexceptflag (fexcept_t *<var>flagp</var>, int <var>excepts</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>int fegetround (void)</code>
 <dd>
 <code>fenv.h</code> (ISO):  <a href="#Rounding">Rounding</a>.
 
 <br><dt><code>int feholdexcept (fenv_t *<var>envp</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Control%20Functions">Control Functions</a>.
+<code>fenv.h</code> (ISO):  <a href="#Control Functions">Control Functions</a>.
 
 <br><dt><code>FE_INEXACT</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>FE_INVALID</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>int feof (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#EOF%20and%20Errors">EOF and Errors</a>.
+<code>stdio.h</code> (ISO):  <a href="#EOF and Errors">EOF and Errors</a>.
 
 <br><dt><code>int feof_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#EOF%20and%20Errors">EOF and Errors</a>.
+<code>stdio.h</code> (GNU):  <a href="#EOF and Errors">EOF and Errors</a>.
 
 <br><dt><code>FE_OVERFLOW</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>int feraiseexcept (int <var>excepts</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>int ferror (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#EOF%20and%20Errors">EOF and Errors</a>.
+<code>stdio.h</code> (ISO):  <a href="#EOF and Errors">EOF and Errors</a>.
 
 <br><dt><code>int ferror_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#EOF%20and%20Errors">EOF and Errors</a>.
+<code>stdio.h</code> (GNU):  <a href="#EOF and Errors">EOF and Errors</a>.
 
 <br><dt><code>int fesetenv (const fenv_t *<var>envp</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Control%20Functions">Control Functions</a>.
+<code>fenv.h</code> (ISO):  <a href="#Control Functions">Control Functions</a>.
 
 <br><dt><code>int fesetexceptflag (const fexcept_t *<var>flagp</var>, int</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>int fesetround (int <var>round</var>)</code>
 <dd>
 <code>fenv.h</code> (ISO):  <a href="#Rounding">Rounding</a>.
 
 <br><dt><code>int fetestexcept (int <var>excepts</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>FE_TONEAREST</code>
 <dd>
 <code>fenv.h</code> (ISO):  <a href="#Rounding">Rounding</a>.
@@ -79236,701 +77627,701 @@
 <code>fenv.h</code> (ISO):  <a href="#Rounding">Rounding</a>.
 
 <br><dt><code>FE_UNDERFLOW</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Status%20bit%20operations">Status bit operations</a>.
+<code>fenv.h</code> (ISO):  <a href="#Status bit operations">Status bit operations</a>.
 
 <br><dt><code>int feupdateenv (const fenv_t *<var>envp</var>)</code>
 <dd>
-<code>fenv.h</code> (ISO):  <a href="#Control%20Functions">Control Functions</a>.
+<code>fenv.h</code> (ISO):  <a href="#Control Functions">Control Functions</a>.
 
 <br><dt><code>FE_UPWARD</code>
 <dd>
 <code>fenv.h</code> (ISO):  <a href="#Rounding">Rounding</a>.
 
 <br><dt><code>int fflush (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Flushing%20Buffers">Flushing Buffers</a>.
+<code>stdio.h</code> (ISO):  <a href="#Flushing Buffers">Flushing Buffers</a>.
 
 <br><dt><code>int fflush_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Flushing%20Buffers">Flushing Buffers</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Flushing Buffers">Flushing Buffers</a>.
 
 <br><dt><code>int fgetc (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Character%20Input">Character Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>int fgetc_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Character%20Input">Character Input</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>int F_GETFD</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Descriptor%20Flags">Descriptor Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Descriptor Flags">Descriptor Flags</a>.
 
 <br><dt><code>int F_GETFL</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Getting%20File%20Status%20Flags">Getting File Status Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Getting File Status Flags">Getting File Status Flags</a>.
 
 <br><dt><code>struct group * fgetgrent (FILE *<var>stream</var>)</code>
 <dd>
-<code>grp.h</code> (SVID):  <a href="#Scanning%20All%20Groups">Scanning All Groups</a>.
+<code>grp.h</code> (SVID):  <a href="#Scanning All Groups">Scanning All Groups</a>.
 
 <br><dt><code>int fgetgrent_r (FILE *<var>stream</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</code>
 <dd>
-<code>grp.h</code> (GNU):  <a href="#Scanning%20All%20Groups">Scanning All Groups</a>.
+<code>grp.h</code> (GNU):  <a href="#Scanning All Groups">Scanning All Groups</a>.
 
 <br><dt><code>int F_GETLK</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#File%20Locks">File Locks</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>int F_GETOWN</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Interrupt%20Input">Interrupt Input</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Interrupt Input">Interrupt Input</a>.
 
 <br><dt><code>int fgetpos (FILE *<var>stream</var>, fpos_t *<var>position</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Portable%20Positioning">Portable Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#Portable Positioning">Portable Positioning</a>.
 
 <br><dt><code>int fgetpos64 (FILE *<var>stream</var>, fpos64_t *<var>position</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#Portable%20Positioning">Portable Positioning</a>.
+<code>stdio.h</code> (Unix98):  <a href="#Portable Positioning">Portable Positioning</a>.
 
 <br><dt><code>struct passwd * fgetpwent (FILE *<var>stream</var>)</code>
 <dd>
-<code>pwd.h</code> (SVID):  <a href="#Scanning%20All%20Users">Scanning All Users</a>.
+<code>pwd.h</code> (SVID):  <a href="#Scanning All Users">Scanning All Users</a>.
 
 <br><dt><code>int fgetpwent_r (FILE *<var>stream</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)</code>
 <dd>
-<code>pwd.h</code> (GNU):  <a href="#Scanning%20All%20Users">Scanning All Users</a>.
+<code>pwd.h</code> (GNU):  <a href="#Scanning All Users">Scanning All Users</a>.
 
 <br><dt><code>char * fgets (char *<var>s</var>, int <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Line%20Input">Line Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Line Input">Line Input</a>.
 
 <br><dt><code>char * fgets_unlocked (char *<var>s</var>, int <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Line%20Input">Line Input</a>.
+<code>stdio.h</code> (GNU):  <a href="#Line Input">Line Input</a>.
 
 <br><dt><code>wint_t fgetwc (FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Character%20Input">Character Input</a>.
+<code>wchar.h</code> (ISO):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>wint_t fgetwc_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Character%20Input">Character Input</a>.
+<code>wchar.h</code> (GNU):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>wchar_t * fgetws (wchar_t *<var>ws</var>, int <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Line%20Input">Line Input</a>.
+<code>wchar.h</code> (ISO):  <a href="#Line Input">Line Input</a>.
 
 <br><dt><code>wchar_t * fgetws_unlocked (wchar_t *<var>ws</var>, int <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Line%20Input">Line Input</a>.
+<code>wchar.h</code> (GNU):  <a href="#Line Input">Line Input</a>.
 
 <br><dt><code>FILE</code>
 <dd>
 <code>stdio.h</code> (ISO):  <a href="#Streams">Streams</a>.
 
 <br><dt><code>int FILENAME_MAX</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>stdio.h</code> (ISO):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>int fileno (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX.1):  <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>.
+<code>stdio.h</code> (POSIX.1):  <a href="#Descriptors and Streams">Descriptors and Streams</a>.
 
 <br><dt><code>int fileno_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>.
+<code>stdio.h</code> (GNU):  <a href="#Descriptors and Streams">Descriptors and Streams</a>.
 
 <br><dt><code>int finite (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int finitef (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int finitel (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int __flbf (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>void flockfile (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Streams%20and%20Threads">Streams and Threads</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Streams and Threads">Streams and Threads</a>.
 
 <br><dt><code>double floor (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>float floorf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long double floorl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>FLT_DIG</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_EPSILON</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_MANT_DIG</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_MAX</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_MAX_10_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_MAX_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_MIN</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_MIN_10_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_MIN_EXP</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_RADIX</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>FLT_ROUNDS</code>
 <dd>
-<code>float.h</code> (ISO):  <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>.
+<code>float.h</code> (ISO):  <a href="#Floating Point Parameters">Floating Point Parameters</a>.
 
 <br><dt><code>void _flushlbf (void)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Flushing%20Buffers">Flushing Buffers</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Flushing Buffers">Flushing Buffers</a>.
 
 <br><dt><code>tcflag_t FLUSHO</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>double fma (double <var>x</var>, double <var>y</var>, double <var>z</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>float fmaf (float <var>x</var>, float <var>y</var>, float <var>z</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>long double fmal (long double <var>x</var>, long double <var>y</var>, long double <var>z</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>double fmax (double <var>x</var>, double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>float fmaxf (float <var>x</var>, float <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>long double fmaxl (long double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>FILE * fmemopen (void *<var>buf</var>, size_t <var>size</var>, const char *<var>opentype</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#String%20Streams">String Streams</a>.
+<code>stdio.h</code> (GNU):  <a href="#String Streams">String Streams</a>.
 
 <br><dt><code>double fmin (double <var>x</var>, double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>float fminf (float <var>x</var>, float <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>long double fminl (long double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>.
+<code>math.h</code> (ISO):  <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>.
 
 <br><dt><code>double fmod (double <var>numerator</var>, double <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>float fmodf (float <var>numerator</var>, float <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>long double fmodl (long double <var>numerator</var>, long double <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>int fmtmsg (long int <var>classification</var>, const char *<var>label</var>, int <var>severity</var>, const char *<var>text</var>, const char *<var>action</var>, const char *<var>tag</var>)</code>
 <dd>
-<code>fmtmsg.h</code> (XPG):  <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>.
+<code>fmtmsg.h</code> (XPG):  <a href="#Printing Formatted Messages">Printing Formatted Messages</a>.
 
 <br><dt><code>int fnmatch (const char *<var>pattern</var>, const char *<var>string</var>, int <var>flags</var>)</code>
 <dd>
-<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>FNM_CASEFOLD</code>
 <dd>
-<code>fnmatch.h</code> (GNU):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (GNU):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>FNM_EXTMATCH</code>
 <dd>
-<code>fnmatch.h</code> (GNU):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (GNU):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>FNM_FILE_NAME</code>
 <dd>
-<code>fnmatch.h</code> (GNU):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (GNU):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>FNM_LEADING_DIR</code>
 <dd>
-<code>fnmatch.h</code> (GNU):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (GNU):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>FNM_NOESCAPE</code>
 <dd>
-<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>FNM_PATHNAME</code>
 <dd>
-<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>FNM_PERIOD</code>
 <dd>
-<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard%20Matching">Wildcard Matching</a>.
+<code>fnmatch.h</code> (POSIX.2):  <a href="#Wildcard Matching">Wildcard Matching</a>.
 
 <br><dt><code>int F_OK</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Testing%20File%20Access">Testing File Access</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Testing File Access">Testing File Access</a>.
 
 <br><dt><code>FILE * fopen (const char *<var>filename</var>, const char *<var>opentype</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio.h</code> (ISO):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>FILE * fopen64 (const char *<var>filename</var>, const char *<var>opentype</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio.h</code> (Unix98):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>FILE * fopencookie (void *<var>cookie</var>, const char *<var>opentype</var>, cookie_io_functions_t <var>io-functions</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Streams%20and%20Cookies">Streams and Cookies</a>.
+<code>stdio.h</code> (GNU):  <a href="#Streams and Cookies">Streams and Cookies</a>.
 
 <br><dt><code>int FOPEN_MAX</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio.h</code> (ISO):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>pid_t fork (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Creating%20a%20Process">Creating a Process</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Creating a Process">Creating a Process</a>.
 
 <br><dt><code>int forkpty (int *<var>amaster</var>, char *<var>name</var>, struct termios *<var>termp</var>, struct winsize *<var>winp</var>)</code>
 <dd>
-<code>pty.h</code> (BSD):  <a href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>.
+<code>pty.h</code> (BSD):  <a href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>.
 
 <br><dt><code>long int fpathconf (int <var>filedes</var>, int <var>parameter</var>)</code>
 <dd>
 <code>unistd.h</code> (POSIX.1):  <a href="#Pathconf">Pathconf</a>.
 
 <br><dt><code>int fpclassify (<em>float-type</em> <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (ISO):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>FPE_DECOVF_TRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_FLTDIV_FAULT</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_FLTDIV_TRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_FLTOVF_FAULT</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_FLTOVF_TRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_FLTUND_FAULT</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_FLTUND_TRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_INTDIV_TRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>FPE_INTOVF_TRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>size_t __fpending (FILE *<var>stream</var>) The <code>__fpending</code></code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>FPE_SUBRNG_TRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int FP_ILOGB0</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>int FP_ILOGBNAN</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>fpos64_t</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#Portable%20Positioning">Portable Positioning</a>.
+<code>stdio.h</code> (Unix98):  <a href="#Portable Positioning">Portable Positioning</a>.
 
 <br><dt><code>fpos_t</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Portable%20Positioning">Portable Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#Portable Positioning">Portable Positioning</a>.
 
 <br><dt><code>int fprintf (FILE *<var>stream</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>.
+<code>stdio.h</code> (ISO):  <a href="#Formatted Output Functions">Formatted Output Functions</a>.
 
 <br><dt><code>void __fpurge (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Flushing%20Buffers">Flushing Buffers</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Flushing Buffers">Flushing Buffers</a>.
 
 <br><dt><code>int fputc (int <var>c</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int fputc_unlocked (int <var>c</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int fputs (const char *<var>s</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int fputs_unlocked (const char *<var>s</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>wint_t fputwc (wchar_t <var>wc</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>wint_t fputwc_unlocked (wint_t <var>wc</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (POSIX):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (POSIX):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int fputws (const wchar_t *<var>ws</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int fputws_unlocked (const wchar_t *<var>ws</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (GNU):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>F_RDLCK</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#File%20Locks">File Locks</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>size_t fread (void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Block%20Input%2fOutput">Block Input/Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Block Input%2fOutput">Block Input/Output</a>.
 
 <br><dt><code>int __freadable (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>int __freading (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>size_t fread_unlocked (void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Block%20Input%2fOutput">Block Input/Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Block Input%2fOutput">Block Input/Output</a>.
 
 <br><dt><code>void free (void *<var>ptr</var>)</code>
 <dd>
-<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>.
+<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Freeing after Malloc">Freeing after Malloc</a>.
 
 <br><dt><code>__free_hook</code>
 <dd>
-<code>malloc.h</code> (GNU):  <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>.
+<code>malloc.h</code> (GNU):  <a href="#Hooks for Malloc">Hooks for Malloc</a>.
 
 <br><dt><code>FILE * freopen (const char *<var>filename</var>, const char *<var>opentype</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio.h</code> (ISO):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>FILE * freopen64 (const char *<var>filename</var>, const char *<var>opentype</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio.h</code> (Unix98):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>double frexp (double <var>value</var>, int *<var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>float frexpf (float <var>value</var>, int *<var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long double frexpl (long double <var>value</var>, int *<var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>int fscanf (FILE *<var>stream</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>.
+<code>stdio.h</code> (ISO):  <a href="#Formatted Input Functions">Formatted Input Functions</a>.
 
 <br><dt><code>int fseek (FILE *<var>stream</var>, long int <var>offset</var>, int <var>whence</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int fseeko (FILE *<var>stream</var>, off_t <var>offset</var>, int <var>whence</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (Unix98):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int fseeko64 (FILE *<var>stream</var>, off64_t <var>offset</var>, int <var>whence</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (Unix98):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int F_SETFD</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Descriptor%20Flags">Descriptor Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Descriptor Flags">Descriptor Flags</a>.
 
 <br><dt><code>int F_SETFL</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Getting%20File%20Status%20Flags">Getting File Status Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Getting File Status Flags">Getting File Status Flags</a>.
 
 <br><dt><code>int F_SETLK</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#File%20Locks">File Locks</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>int F_SETLKW</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#File%20Locks">File Locks</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>int __fsetlocking (FILE *<var>stream</var>, int <var>type</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Streams%20and%20Threads">Streams and Threads</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Streams and Threads">Streams and Threads</a>.
 
 <br><dt><code>int F_SETOWN</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Interrupt%20Input">Interrupt Input</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Interrupt Input">Interrupt Input</a>.
 
 <br><dt><code>int fsetpos (FILE *<var>stream</var>, const fpos_t *<var>position</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Portable%20Positioning">Portable Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#Portable Positioning">Portable Positioning</a>.
 
 <br><dt><code>int fsetpos64 (FILE *<var>stream</var>, const fpos64_t *<var>position</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#Portable%20Positioning">Portable Positioning</a>.
+<code>stdio.h</code> (Unix98):  <a href="#Portable Positioning">Portable Positioning</a>.
 
 <br><dt><code>int fstat (int <var>filedes</var>, struct stat *<var>buf</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Reading%20Attributes">Reading Attributes</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Reading Attributes">Reading Attributes</a>.
 
 <br><dt><code>int fstat64 (int <var>filedes</var>, struct stat64 *<var>buf</var>)</code>
 <dd>
-<code>sys/stat.h</code> (Unix98):  <a href="#Reading%20Attributes">Reading Attributes</a>.
+<code>sys/stat.h</code> (Unix98):  <a href="#Reading Attributes">Reading Attributes</a>.
 
 <br><dt><code>int fsync (int <var>fildes</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX):  <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>.
+<code>unistd.h</code> (POSIX):  <a href="#Synchronizing I%2fO">Synchronizing I/O</a>.
 
 <br><dt><code>long int ftell (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>off_t ftello (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (Unix98):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>off64_t ftello64 (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (Unix98):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int ftruncate (int <var>fd</var>, off_t <var>length</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX):  <a href="#File%20Size">File Size</a>.
+<code>unistd.h</code> (POSIX):  <a href="#File Size">File Size</a>.
 
 <br><dt><code>int ftruncate64 (int <var>id</var>, off64_t <var>length</var>)</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#File%20Size">File Size</a>.
+<code>unistd.h</code> (Unix98):  <a href="#File Size">File Size</a>.
 
 <br><dt><code>int ftrylockfile (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Streams%20and%20Threads">Streams and Threads</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Streams and Threads">Streams and Threads</a>.
 
 <br><dt><code>int ftw (const char *<var>filename</var>, __ftw_func_t <var>func</var>, int <var>descriptors</var>)</code>
 <dd>
-<code>ftw.h</code> (SVID):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (SVID):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>int ftw64 (const char *<var>filename</var>, __ftw64_func_t <var>func</var>, int <var>descriptors</var>)</code>
 <dd>
-<code>ftw.h</code> (Unix98):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (Unix98):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>__ftw64_func_t</code>
 <dd>
-<code>ftw.h</code> (GNU):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (GNU):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>__ftw_func_t</code>
 <dd>
-<code>ftw.h</code> (GNU):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (GNU):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>F_UNLCK</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#File%20Locks">File Locks</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>void funlockfile (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Streams%20and%20Threads">Streams and Threads</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Streams and Threads">Streams and Threads</a>.
 
 <br><dt><code>int fwide (FILE *<var>stream</var>, int <var>mode</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Streams%20and%20I18N">Streams and I18N</a>.
+<code>wchar.h</code> (ISO):  <a href="#Streams and I18N">Streams and I18N</a>.
 
 <br><dt><code>int fwprintf (FILE *<var>stream</var>, const wchar_t *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Formatted Output Functions">Formatted Output Functions</a>.
 
 <br><dt><code>int __fwritable (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>size_t fwrite (const void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Block%20Input%2fOutput">Block Input/Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Block Input%2fOutput">Block Input/Output</a>.
 
 <br><dt><code>size_t fwrite_unlocked (const void *<var>data</var>, size_t <var>size</var>, size_t <var>count</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Block%20Input%2fOutput">Block Input/Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Block Input%2fOutput">Block Input/Output</a>.
 
 <br><dt><code>int __fwriting (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio_ext.h</code> (GNU):  <a href="#Opening%20Streams">Opening Streams</a>.
+<code>stdio_ext.h</code> (GNU):  <a href="#Opening Streams">Opening Streams</a>.
 
 <br><dt><code>F_WRLCK</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#File%20Locks">File Locks</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>int fwscanf (FILE *<var>stream</var>, const wchar_t *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Formatted Input Functions">Formatted Input Functions</a>.
 
 <br><dt><code>double gamma (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float gammaf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double gammal (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>void (*__gconv_end_fct) (struct gconv_step *)</code>
 <dd>
-<code>gconv.h</code> (GNU):  <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>.
+<code>gconv.h</code> (GNU):  <a href="#glibc iconv Implementation">glibc iconv Implementation</a>.
 
 <br><dt><code>int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *, const char **, const char *, size_t *, int)</code>
 <dd>
-<code>gconv.h</code> (GNU):  <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>.
+<code>gconv.h</code> (GNU):  <a href="#glibc iconv Implementation">glibc iconv Implementation</a>.
 
 <br><dt><code>int (*__gconv_init_fct) (struct __gconv_step *)</code>
 <dd>
-<code>gconv.h</code> (GNU):  <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>.
+<code>gconv.h</code> (GNU):  <a href="#glibc iconv Implementation">glibc iconv Implementation</a>.
 
 <br><dt><code>char * gcvt (double <var>value</var>, int <var>ndigit</var>, char *<var>buf</var>)</code>
 <dd>
-<code>stdlib.h</code> (SVID, Unix98):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (SVID, Unix98):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>long int get_avphys_pages (void)</code>
 <dd>
-<code>sys/sysinfo.h</code> (GNU):  <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>.
+<code>sys/sysinfo.h</code> (GNU):  <a href="#Query Memory Parameters">Query Memory Parameters</a>.
 
 <br><dt><code>int getc (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Character%20Input">Character Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>int getchar (void)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Character%20Input">Character Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>int getchar_unlocked (void)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Character%20Input">Character Input</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>int getcontext (ucontext_t *<var>ucp</var>)</code>
 <dd>
-<code>ucontext.h</code> (SVID):  <a href="#System%20V%20contexts">System V contexts</a>.
+<code>ucontext.h</code> (SVID):  <a href="#System V contexts">System V contexts</a>.
 
 <br><dt><code>int getc_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Character%20Input">Character Input</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>char * get_current_dir_name (void)</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Working%20Directory">Working Directory</a>.
+<code>unistd.h</code> (GNU):  <a href="#Working Directory">Working Directory</a>.
 
 <br><dt><code>char * getcwd (char *<var>buffer</var>, size_t <var>size</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Working%20Directory">Working Directory</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Working Directory">Working Directory</a>.
 
 <br><dt><code>struct tm * getdate (const char *<var>string</var>)</code>
 <dd>
-<code>time.h</code> (Unix98):  <a href="#General%20Time%20String%20Parsing">General Time String Parsing</a>.
+<code>time.h</code> (Unix98):  <a href="#General Time String Parsing">General Time String Parsing</a>.
 
 <br><dt><code>getdate_err</code>
 <dd>
-<code>time.h</code> (Unix98):  <a href="#General%20Time%20String%20Parsing">General Time String Parsing</a>.
+<code>time.h</code> (Unix98):  <a href="#General Time String Parsing">General Time String Parsing</a>.
 
 <br><dt><code>int getdate_r (const char *<var>string</var>, struct tm *<var>tp</var>)</code>
 <dd>
-<code>time.h</code> (GNU):  <a href="#General%20Time%20String%20Parsing">General Time String Parsing</a>.
+<code>time.h</code> (GNU):  <a href="#General Time String Parsing">General Time String Parsing</a>.
 
 <br><dt><code>ssize_t getdelim (char **<var>lineptr</var>, size_t *<var>n</var>, int <var>delimiter</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Line%20Input">Line Input</a>.
+<code>stdio.h</code> (GNU):  <a href="#Line Input">Line Input</a>.
 
 <br><dt><code>int getdomainnname (char *<var>name</var>, size_t <var>length</var>)</code>
 <dd>
-<code>unistd.h</code> (???):  <a href="#Host%20Identification">Host Identification</a>.
+<code>unistd.h</code> (???):  <a href="#Host Identification">Host Identification</a>.
 
 <br><dt><code>gid_t getegid (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Reading%20Persona">Reading Persona</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Reading Persona">Reading Persona</a>.
 
 <br><dt><code>char * getenv (const char *<var>name</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Environment%20Access">Environment Access</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Environment Access">Environment Access</a>.
 
 <br><dt><code>uid_t geteuid (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Reading%20Persona">Reading Persona</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Reading Persona">Reading Persona</a>.
 
 <br><dt><code>struct fstab * getfsent (void)</code>
 <dd>
 <code>fstab.h</code> (BSD):  <a href="#fstab">fstab</a>.
@@ -79944,93 +78335,93 @@
 <code>fstab.h</code> (BSD):  <a href="#fstab">fstab</a>.
 
 <br><dt><code>gid_t getgid (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Reading%20Persona">Reading Persona</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Reading Persona">Reading Persona</a>.
 
 <br><dt><code>struct group * getgrent (void)</code>
 <dd>
-<code>grp.h</code> (SVID, BSD):  <a href="#Scanning%20All%20Groups">Scanning All Groups</a>.
+<code>grp.h</code> (SVID, BSD):  <a href="#Scanning All Groups">Scanning All Groups</a>.
 
 <br><dt><code>int getgrent_r (struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</code>
 <dd>
-<code>grp.h</code> (GNU):  <a href="#Scanning%20All%20Groups">Scanning All Groups</a>.
+<code>grp.h</code> (GNU):  <a href="#Scanning All Groups">Scanning All Groups</a>.
 
 <br><dt><code>struct group * getgrgid (gid_t <var>gid</var>)</code>
 <dd>
-<code>grp.h</code> (POSIX.1):  <a href="#Lookup%20Group">Lookup Group</a>.
+<code>grp.h</code> (POSIX.1):  <a href="#Lookup Group">Lookup Group</a>.
 
 <br><dt><code>int getgrgid_r (gid_t <var>gid</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</code>
 <dd>
-<code>grp.h</code> (POSIX.1c):  <a href="#Lookup%20Group">Lookup Group</a>.
+<code>grp.h</code> (POSIX.1c):  <a href="#Lookup Group">Lookup Group</a>.
 
 <br><dt><code>struct group * getgrnam (const char *<var>name</var>)</code>
 <dd>
-<code>grp.h</code> (SVID, BSD):  <a href="#Lookup%20Group">Lookup Group</a>.
+<code>grp.h</code> (SVID, BSD):  <a href="#Lookup Group">Lookup Group</a>.
 
 <br><dt><code>int getgrnam_r (const char *<var>name</var>, struct group *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct group **<var>result</var>)</code>
 <dd>
-<code>grp.h</code> (POSIX.1c):  <a href="#Lookup%20Group">Lookup Group</a>.
+<code>grp.h</code> (POSIX.1c):  <a href="#Lookup Group">Lookup Group</a>.
 
 <br><dt><code>int getgrouplist (const char *<var>user</var>, gid_t <var>group</var>, gid_t *<var>groups</var>, int *<var>ngroups</var>)</code>
 <dd>
-<code>grp.h</code> (BSD):  <a href="#Setting%20Groups">Setting Groups</a>.
+<code>grp.h</code> (BSD):  <a href="#Setting Groups">Setting Groups</a>.
 
 <br><dt><code>int getgroups (int <var>count</var>, gid_t *<var>groups</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Reading%20Persona">Reading Persona</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Reading Persona">Reading Persona</a>.
 
 <br><dt><code>struct hostent * gethostbyaddr (const char *<var>addr</var>, size_t <var>length</var>, int <var>format</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>int gethostbyaddr_r (const char *<var>addr</var>, size_t <var>length</var>, int <var>format</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)</code>
 <dd>
-<code>netdb.h</code> (GNU):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (GNU):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>struct hostent * gethostbyname (const char *<var>name</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>struct hostent * gethostbyname2 (const char *<var>name</var>, int <var>af</var>)</code>
 <dd>
-<code>netdb.h</code> (IPv6 Basic API):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (IPv6 Basic API):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>int gethostbyname2_r (const char *<var>name</var>, int <var>af</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)</code>
 <dd>
-<code>netdb.h</code> (GNU):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (GNU):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>int gethostbyname_r (const char *restrict <var>name</var>, struct hostent *restrict <var>result_buf</var>, char *restrict <var>buf</var>, size_t <var>buflen</var>, struct hostent **restrict <var>result</var>, int *restrict <var>h_errnop</var>)</code>
 <dd>
-<code>netdb.h</code> (GNU):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (GNU):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>struct hostent * gethostent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>long int gethostid (void)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Host%20Identification">Host Identification</a>.
+<code>unistd.h</code> (BSD):  <a href="#Host Identification">Host Identification</a>.
 
 <br><dt><code>int gethostname (char *<var>name</var>, size_t <var>size</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Host%20Identification">Host Identification</a>.
+<code>unistd.h</code> (BSD):  <a href="#Host Identification">Host Identification</a>.
 
 <br><dt><code>int getitimer (int <var>which</var>, struct itimerval *<var>old</var>)</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<code>sys/time.h</code> (BSD):  <a href="#Setting an Alarm">Setting an Alarm</a>.
 
 <br><dt><code>ssize_t getline (char **<var>lineptr</var>, size_t *<var>n</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Line%20Input">Line Input</a>.
+<code>stdio.h</code> (GNU):  <a href="#Line Input">Line Input</a>.
 
 <br><dt><code>int getloadavg (double <var>loadavg</var>[], int <var>nelem</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#Processor%20Resources">Processor Resources</a>.
+<code>stdlib.h</code> (BSD):  <a href="#Processor Resources">Processor Resources</a>.
 
 <br><dt><code>char * getlogin (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Who%20Logged%20In">Who Logged In</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Who Logged In">Who Logged In</a>.
 
 <br><dt><code>struct mntent * getmntent (FILE *<var>stream</var>)</code>
 <dd>
 <code>mntent.h</code> (BSD):  <a href="#mtab">mtab</a>.
@@ -80040,669 +78431,669 @@
 <code>mntent.h</code> (BSD):  <a href="#mtab">mtab</a>.
 
 <br><dt><code>struct netent * getnetbyaddr (unsigned long int <var>net</var>, int <var>type</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Networks%20Database">Networks Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Networks Database">Networks Database</a>.
 
 <br><dt><code>struct netent * getnetbyname (const char *<var>name</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Networks%20Database">Networks Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Networks Database">Networks Database</a>.
 
 <br><dt><code>struct netent * getnetent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Networks%20Database">Networks Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Networks Database">Networks Database</a>.
 
 <br><dt><code>int getnetgrent (char **<var>hostp</var>, char **<var>userp</var>, char **<var>domainp</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Lookup%20Netgroup">Lookup Netgroup</a>.
+<code>netdb.h</code> (BSD):  <a href="#Lookup Netgroup">Lookup Netgroup</a>.
 
 <br><dt><code>int getnetgrent_r (char **<var>hostp</var>, char **<var>userp</var>, char **<var>domainp</var>, char *<var>buffer</var>, int <var>buflen</var>)</code>
 <dd>
-<code>netdb.h</code> (GNU):  <a href="#Lookup%20Netgroup">Lookup Netgroup</a>.
+<code>netdb.h</code> (GNU):  <a href="#Lookup Netgroup">Lookup Netgroup</a>.
 
 <br><dt><code>int get_nprocs (void)</code>
 <dd>
-<code>sys/sysinfo.h</code> (GNU):  <a href="#Processor%20Resources">Processor Resources</a>.
+<code>sys/sysinfo.h</code> (GNU):  <a href="#Processor Resources">Processor Resources</a>.
 
 <br><dt><code>int get_nprocs_conf (void)</code>
 <dd>
-<code>sys/sysinfo.h</code> (GNU):  <a href="#Processor%20Resources">Processor Resources</a>.
+<code>sys/sysinfo.h</code> (GNU):  <a href="#Processor Resources">Processor Resources</a>.
 
 <br><dt><code>int getopt (int <var>argc</var>, char **<var>argv</var>, const char *<var>options</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Using%20Getopt">Using Getopt</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Using Getopt">Using Getopt</a>.
 
 <br><dt><code>int getopt_long (int <var>argc</var>, char *const *<var>argv</var>, const char *<var>shortopts</var>, const struct option *<var>longopts</var>, int *<var>indexptr</var>)</code>
 <dd>
-<code>getopt.h</code> (GNU):  <a href="#Getopt%20Long%20Options">Getopt Long Options</a>.
+<code>getopt.h</code> (GNU):  <a href="#Getopt Long Options">Getopt Long Options</a>.
 
 <br><dt><code>int getopt_long_only (int <var>argc</var>, char *const *<var>argv</var>, const char *<var>shortopts</var>, const struct option *<var>longopts</var>, int *<var>indexptr</var>)</code>
 <dd>
-<code>getopt.h</code> (GNU):  <a href="#Getopt%20Long%20Options">Getopt Long Options</a>.
+<code>getopt.h</code> (GNU):  <a href="#Getopt Long Options">Getopt Long Options</a>.
 
 <br><dt><code>int getpagesize (void)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>.
+<code>unistd.h</code> (BSD):  <a href="#Query Memory Parameters">Query Memory Parameters</a>.
 
 <br><dt><code>char * getpass (const char *<var>prompt</var>)</code>
 <dd>
 <code>unistd.h</code> (BSD):  <a href="#getpass">getpass</a>.
 
 <br><dt><code>int getpeername (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Who%20is%20Connected">Who is Connected</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Who is Connected">Who is Connected</a>.
 
 <br><dt><code>int getpgid (pid_t <var>pid</var>)</code>
 <dd>
-<code>unistd.h</code> (SVID):  <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+<code>unistd.h</code> (SVID):  <a href="#Process Group Functions">Process Group Functions</a>.
 
 <br><dt><code>pid_t getpgrp (pid_t <var>pid</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+<code>unistd.h</code> (BSD):  <a href="#Process Group Functions">Process Group Functions</a>.
 
 <br><dt><code>pid_t getpgrp (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Process Group Functions">Process Group Functions</a>.
 
 <br><dt><code>long int get_phys_pages (void)</code>
 <dd>
-<code>sys/sysinfo.h</code> (GNU):  <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>.
+<code>sys/sysinfo.h</code> (GNU):  <a href="#Query Memory Parameters">Query Memory Parameters</a>.
 
 <br><dt><code>pid_t getpid (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Process%20Identification">Process Identification</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Process Identification">Process Identification</a>.
 
 <br><dt><code>pid_t getppid (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Process%20Identification">Process Identification</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Process Identification">Process Identification</a>.
 
 <br><dt><code>int getpriority (int <var>class</var>, int <var>id</var>)</code>
 <dd>
-<code>sys/resource.h</code> (BSD,POSIX):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>sys/resource.h</code> (BSD,POSIX):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>struct protoent * getprotobyname (const char *<var>name</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Protocols%20Database">Protocols Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Protocols Database">Protocols Database</a>.
 
 <br><dt><code>struct protoent * getprotobynumber (int <var>protocol</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Protocols%20Database">Protocols Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Protocols Database">Protocols Database</a>.
 
 <br><dt><code>struct protoent * getprotoent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Protocols%20Database">Protocols Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Protocols Database">Protocols Database</a>.
 
 <br><dt><code>int getpt (void)</code>
 <dd>
 <code>stdlib.h</code> (GNU):  <a href="#Allocation">Allocation</a>.
 
 <br><dt><code>struct passwd * getpwent (void)</code>
 <dd>
-<code>pwd.h</code> (POSIX.1):  <a href="#Scanning%20All%20Users">Scanning All Users</a>.
+<code>pwd.h</code> (POSIX.1):  <a href="#Scanning All Users">Scanning All Users</a>.
 
 <br><dt><code>int getpwent_r (struct passwd *<var>result_buf</var>, char *<var>buffer</var>, int <var>buflen</var>, struct passwd **<var>result</var>)</code>
 <dd>
-<code>pwd.h</code> (GNU):  <a href="#Scanning%20All%20Users">Scanning All Users</a>.
+<code>pwd.h</code> (GNU):  <a href="#Scanning All Users">Scanning All Users</a>.
 
 <br><dt><code>struct passwd * getpwnam (const char *<var>name</var>)</code>
 <dd>
-<code>pwd.h</code> (POSIX.1):  <a href="#Lookup%20User">Lookup User</a>.
+<code>pwd.h</code> (POSIX.1):  <a href="#Lookup User">Lookup User</a>.
 
 <br><dt><code>int getpwnam_r (const char *<var>name</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)</code>
 <dd>
-<code>pwd.h</code> (POSIX.1c):  <a href="#Lookup%20User">Lookup User</a>.
+<code>pwd.h</code> (POSIX.1c):  <a href="#Lookup User">Lookup User</a>.
 
 <br><dt><code>struct passwd * getpwuid (uid_t <var>uid</var>)</code>
 <dd>
-<code>pwd.h</code> (POSIX.1):  <a href="#Lookup%20User">Lookup User</a>.
+<code>pwd.h</code> (POSIX.1):  <a href="#Lookup User">Lookup User</a>.
 
 <br><dt><code>int getpwuid_r (uid_t <var>uid</var>, struct passwd *<var>result_buf</var>, char *<var>buffer</var>, size_t <var>buflen</var>, struct passwd **<var>result</var>)</code>
 <dd>
-<code>pwd.h</code> (POSIX.1c):  <a href="#Lookup%20User">Lookup User</a>.
+<code>pwd.h</code> (POSIX.1c):  <a href="#Lookup User">Lookup User</a>.
 
 <br><dt><code>int getrlimit (int <var>resource</var>, struct rlimit *<var>rlp</var>)</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>int getrlimit64 (int <var>resource</var>, struct rlimit64 *<var>rlp</var>)</code>
 <dd>
-<code>sys/resource.h</code> (Unix98):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (Unix98):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>int getrusage (int <var>processes</var>, struct rusage *<var>rusage</var>)</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Resource%20Usage">Resource Usage</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Resource Usage">Resource Usage</a>.
 
 <br><dt><code>char * gets (char *<var>s</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Line%20Input">Line Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Line Input">Line Input</a>.
 
 <br><dt><code>struct servent * getservbyname (const char *<var>name</var>, const char *<var>proto</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Services%20Database">Services Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Services Database">Services Database</a>.
 
 <br><dt><code>struct servent * getservbyport (int <var>port</var>, const char *<var>proto</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Services%20Database">Services Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Services Database">Services Database</a>.
 
 <br><dt><code>struct servent * getservent (void)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Services%20Database">Services Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Services Database">Services Database</a>.
 
 <br><dt><code>pid_t getsid (pid_t <var>pid</var>)</code>
 <dd>
-<code>unistd.h</code> (SVID):  <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+<code>unistd.h</code> (SVID):  <a href="#Process Group Functions">Process Group Functions</a>.
 
 <br><dt><code>int getsockname (int <var>socket</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Reading%20Address">Reading Address</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Reading Address">Reading Address</a>.
 
 <br><dt><code>int getsockopt (int <var>socket</var>, int <var>level</var>, int <var>optname</var>, void *<var>optval</var>, socklen_t *<var>optlen-ptr</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket%20Option%20Functions">Socket Option Functions</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket Option Functions">Socket Option Functions</a>.
 
 <br><dt><code>int getsubopt (char **<var>optionp</var>, const char* const *<var>tokens</var>, char **<var>valuep</var>)</code>
 <dd>
 <code>stdlib.h</code> (stdlib.h):  <a href="#Suboptions">Suboptions Example</a>.
 
 <br><dt><code>char * gettext (const char *<var>msgid</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Translation%20with%20gettext">Translation with gettext</a>.
+<code>libintl.h</code> (GNU):  <a href="#Translation with gettext">Translation with gettext</a>.
 
 <br><dt><code>int gettimeofday (struct timeval *<var>tp</var>, struct timezone *<var>tzp</var>)</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.
+<code>sys/time.h</code> (BSD):  <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.
 
 <br><dt><code>uid_t getuid (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Reading%20Persona">Reading Persona</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Reading Persona">Reading Persona</a>.
 
 <br><dt><code>mode_t getumask (void)</code>
 <dd>
-<code>sys/stat.h</code> (GNU):  <a href="#Setting%20Permissions">Setting Permissions</a>.
+<code>sys/stat.h</code> (GNU):  <a href="#Setting Permissions">Setting Permissions</a>.
 
 <br><dt><code>struct utmp * getutent (void)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>int getutent_r (struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)</code>
 <dd>
-<code>utmp.h</code> (GNU):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (GNU):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>struct utmp * getutid (const struct utmp *<var>id</var>)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>int getutid_r (const struct utmp *<var>id</var>, struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)</code>
 <dd>
-<code>utmp.h</code> (GNU):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (GNU):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>struct utmp * getutline (const struct utmp *<var>line</var>)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>int getutline_r (const struct utmp *<var>line</var>, struct utmp *<var>buffer</var>, struct utmp **<var>result</var>)</code>
 <dd>
-<code>utmp.h</code> (GNU):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (GNU):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>int getutmp (const struct utmpx *utmpx, struct utmp *utmp)</code>
 <dd>
-<code>utmp.h</code> (GNU):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmp.h</code> (GNU):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int getutmpx (const struct utmp *utmp, struct utmpx *utmpx)</code>
 <dd>
-<code>utmp.h</code> (GNU):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmp.h</code> (GNU):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>struct utmpx * getutxent (void)</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>struct utmpx * getutxid (const struct utmpx *<var>id</var>)</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>struct utmpx * getutxline (const struct utmpx *<var>line</var>)</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int getw (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (SVID):  <a href="#Character%20Input">Character Input</a>.
+<code>stdio.h</code> (SVID):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>wint_t getwc (FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Character%20Input">Character Input</a>.
+<code>wchar.h</code> (ISO):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>wint_t getwchar (void)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Character%20Input">Character Input</a>.
+<code>wchar.h</code> (ISO):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>wint_t getwchar_unlocked (void)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Character%20Input">Character Input</a>.
+<code>wchar.h</code> (GNU):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>wint_t getwc_unlocked (FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Character%20Input">Character Input</a>.
+<code>wchar.h</code> (GNU):  <a href="#Character Input">Character Input</a>.
 
 <br><dt><code>char * getwd (char *<var>buffer</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Working%20Directory">Working Directory</a>.
+<code>unistd.h</code> (BSD):  <a href="#Working Directory">Working Directory</a>.
 
 <br><dt><code>gid_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#Reading%20Persona">Reading Persona</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#Reading Persona">Reading Persona</a>.
 
 <br><dt><code>int glob (const char *<var>pattern</var>, int <var>flags</var>, int (*<var>errfunc</var>) (const char *<var>filename</var>, int <var>error-code</var>), glob_t *<var>vector-ptr</var>)</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Calling%20Glob">Calling Glob</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Calling Glob">Calling Glob</a>.
 
 <br><dt><code>int glob64 (const char *<var>pattern</var>, int <var>flags</var>, int (*<var>errfunc</var>) (const char *<var>filename</var>, int <var>error-code</var>), glob64_t *<var>vector-ptr</var>)</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#Calling%20Glob">Calling Glob</a>.
+<code>glob.h</code> (GNU):  <a href="#Calling Glob">Calling Glob</a>.
 
 <br><dt><code>glob64_t</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#Calling%20Glob">Calling Glob</a>.
+<code>glob.h</code> (GNU):  <a href="#Calling Glob">Calling Glob</a>.
 
 <br><dt><code>GLOB_ABORTED</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Calling%20Glob">Calling Glob</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Calling Glob">Calling Glob</a>.
 
 <br><dt><code>GLOB_ALTDIRFUNC</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>GLOB_APPEND</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Flags%20for%20Globbing">Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Flags for Globbing">Flags for Globbing</a>.
 
 <br><dt><code>GLOB_BRACE</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>GLOB_DOOFFS</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Flags%20for%20Globbing">Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Flags for Globbing">Flags for Globbing</a>.
 
 <br><dt><code>GLOB_ERR</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Flags%20for%20Globbing">Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Flags for Globbing">Flags for Globbing</a>.
 
 <br><dt><code>void globfree (glob_t *<var>pglob</var>)</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>void globfree64 (glob64_t *<var>pglob</var>)</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>GLOB_MAGCHAR</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>GLOB_MARK</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Flags%20for%20Globbing">Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Flags for Globbing">Flags for Globbing</a>.
 
 <br><dt><code>GLOB_NOCHECK</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Flags%20for%20Globbing">Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Flags for Globbing">Flags for Globbing</a>.
 
 <br><dt><code>GLOB_NOESCAPE</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Flags%20for%20Globbing">Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Flags for Globbing">Flags for Globbing</a>.
 
 <br><dt><code>GLOB_NOMAGIC</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>GLOB_NOMATCH</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Calling%20Glob">Calling Glob</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Calling Glob">Calling Glob</a>.
 
 <br><dt><code>GLOB_NOSORT</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Flags%20for%20Globbing">Flags for Globbing</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Flags for Globbing">Flags for Globbing</a>.
 
 <br><dt><code>GLOB_NOSPACE</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Calling%20Glob">Calling Glob</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Calling Glob">Calling Glob</a>.
 
 <br><dt><code>GLOB_ONLYDIR</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>GLOB_PERIOD</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>glob_t</code>
 <dd>
-<code>glob.h</code> (POSIX.2):  <a href="#Calling%20Glob">Calling Glob</a>.
+<code>glob.h</code> (POSIX.2):  <a href="#Calling Glob">Calling Glob</a>.
 
 <br><dt><code>GLOB_TILDE</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>GLOB_TILDE_CHECK</code>
 <dd>
-<code>glob.h</code> (GNU):  <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>.
+<code>glob.h</code> (GNU):  <a href="#More Flags for Globbing">More Flags for Globbing</a>.
 
 <br><dt><code>struct tm * gmtime (const time_t *<var>time</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (ISO):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>struct tm * gmtime_r (const time_t *<var>time</var>, struct tm *<var>resultp</var>)</code>
 <dd>
-<code>time.h</code> (POSIX.1c):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (POSIX.1c):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>_GNU_SOURCE</code>
 <dd>
-(GNU):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(GNU):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>int grantpt (int <var>filedes</var>)</code>
 <dd>
 <code>stdlib.h</code> (SVID, XPG4.2):  <a href="#Allocation">Allocation</a>.
 
 <br><dt><code>int gsignal (int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (SVID):  <a href="#Signaling%20Yourself">Signaling Yourself</a>.
+<code>signal.h</code> (SVID):  <a href="#Signaling Yourself">Signaling Yourself</a>.
 
 <br><dt><code>int gtty (int <var>filedes</var>, struct sgttyb *<var>attributes</var>)</code>
 <dd>
-<code>sgtty.h</code> (BSD):  <a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>.
+<code>sgtty.h</code> (BSD):  <a href="#BSD Terminal Modes">BSD Terminal Modes</a>.
 
 <br><dt><code>char * hasmntopt (const struct mntent *<var>mnt</var>, const char *<var>opt</var>)</code>
 <dd>
 <code>mntent.h</code> (BSD):  <a href="#mtab">mtab</a>.
 
 <br><dt><code>int hcreate (size_t <var>nel</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Hash%20Search%20Function">Hash Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Hash Search Function">Hash Search Function</a>.
 
 <br><dt><code>int hcreate_r (size_t <var>nel</var>, struct hsearch_data *<var>htab</var>)</code>
 <dd>
-<code>search.h</code> (GNU):  <a href="#Hash%20Search%20Function">Hash Search Function</a>.
+<code>search.h</code> (GNU):  <a href="#Hash Search Function">Hash Search Function</a>.
 
 <br><dt><code>void hdestroy (void)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Hash%20Search%20Function">Hash Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Hash Search Function">Hash Search Function</a>.
 
 <br><dt><code>void hdestroy_r (struct hsearch_data *<var>htab</var>)</code>
 <dd>
-<code>search.h</code> (GNU):  <a href="#Hash%20Search%20Function">Hash Search Function</a>.
+<code>search.h</code> (GNU):  <a href="#Hash Search Function">Hash Search Function</a>.
 
 <br><dt><code>HOST_NOT_FOUND</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>ENTRY * hsearch (ENTRY <var>item</var>, ACTION <var>action</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Hash%20Search%20Function">Hash Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Hash Search Function">Hash Search Function</a>.
 
 <br><dt><code>int hsearch_r (ENTRY <var>item</var>, ACTION <var>action</var>, ENTRY **<var>retval</var>, struct hsearch_data *<var>htab</var>)</code>
 <dd>
-<code>search.h</code> (GNU):  <a href="#Hash%20Search%20Function">Hash Search Function</a>.
+<code>search.h</code> (GNU):  <a href="#Hash Search Function">Hash Search Function</a>.
 
 <br><dt><code>uint32_t htonl (uint32_t <var>hostlong</var>)</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Byte%20Order">Byte Order</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Byte Order">Byte Order</a>.
 
 <br><dt><code>uint16_t htons (uint16_t <var>hostshort</var>)</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Byte%20Order">Byte Order</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Byte Order">Byte Order</a>.
 
 <br><dt><code>double HUGE_VAL</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Math%20Error%20Reporting">Math Error Reporting</a>.
+<code>math.h</code> (ISO):  <a href="#Math Error Reporting">Math Error Reporting</a>.
 
 <br><dt><code>float HUGE_VALF</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Math%20Error%20Reporting">Math Error Reporting</a>.
+<code>math.h</code> (ISO):  <a href="#Math Error Reporting">Math Error Reporting</a>.
 
 <br><dt><code>long double HUGE_VALL</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Math%20Error%20Reporting">Math Error Reporting</a>.
+<code>math.h</code> (ISO):  <a href="#Math Error Reporting">Math Error Reporting</a>.
 
 <br><dt><code>tcflag_t HUPCL</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>double hypot (double <var>x</var>, double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float hypotf (float <var>x</var>, float <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double hypotl (long double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>tcflag_t ICANON</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>size_t iconv (iconv_t <var>cd</var>, char **<var>inbuf</var>, size_t *<var>inbytesleft</var>, char **<var>outbuf</var>, size_t *<var>outbytesleft</var>)</code>
 <dd>
-<code>iconv.h</code> (XPG2):  <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>.
+<code>iconv.h</code> (XPG2):  <a href="#Generic Conversion Interface">Generic Conversion Interface</a>.
 
 <br><dt><code>int iconv_close (iconv_t <var>cd</var>)</code>
 <dd>
-<code>iconv.h</code> (XPG2):  <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>.
+<code>iconv.h</code> (XPG2):  <a href="#Generic Conversion Interface">Generic Conversion Interface</a>.
 
 <br><dt><code>iconv_t iconv_open (const char *<var>tocode</var>, const char *<var>fromcode</var>)</code>
 <dd>
-<code>iconv.h</code> (XPG2):  <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>.
+<code>iconv.h</code> (XPG2):  <a href="#Generic Conversion Interface">Generic Conversion Interface</a>.
 
 <br><dt><code>iconv_t</code>
 <dd>
-<code>iconv.h</code> (XPG2):  <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>.
+<code>iconv.h</code> (XPG2):  <a href="#Generic Conversion Interface">Generic Conversion Interface</a>.
 
 <br><dt><code>tcflag_t ICRNL</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>tcflag_t IEXTEN</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>void if_freenameindex (struct if_nameindex *ptr)</code>
 <dd>
-<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface%20Naming">Interface Naming</a>.
+<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface Naming">Interface Naming</a>.
 
 <br><dt><code>char * if_indextoname (unsigned int ifindex, char *ifname)</code>
 <dd>
-<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface%20Naming">Interface Naming</a>.
+<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface Naming">Interface Naming</a>.
 
 <br><dt><code>struct if_nameindex * if_nameindex (void)</code>
 <dd>
-<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface%20Naming">Interface Naming</a>.
+<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface Naming">Interface Naming</a>.
 
 <br><dt><code>unsigned int if_nametoindex (const char *ifname)</code>
 <dd>
-<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface%20Naming">Interface Naming</a>.
+<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface Naming">Interface Naming</a>.
 
 <br><dt><code>size_t IFNAMSIZ</code>
 <dd>
-<code>net/if.h</code> (net/if.h):  <a href="#Interface%20Naming">Interface Naming</a>.
+<code>net/if.h</code> (net/if.h):  <a href="#Interface Naming">Interface Naming</a>.
 
 <br><dt><code>int IFTODT (mode_t <var>mode</var>)</code>
 <dd>
-<code>dirent.h</code> (BSD):  <a href="#Directory%20Entries">Directory Entries</a>.
+<code>dirent.h</code> (BSD):  <a href="#Directory Entries">Directory Entries</a>.
 
 <br><dt><code>tcflag_t IGNBRK</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>tcflag_t IGNCR</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>tcflag_t IGNPAR</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>int ilogb (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>int ilogbf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>int ilogbl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>intmax_t imaxabs (intmax_t <var>number</var>)</code>
 <dd>
-<code>inttypes.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>inttypes.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>tcflag_t IMAXBEL</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>imaxdiv_t imaxdiv (intmax_t <var>numerator</var>, intmax_t <var>denominator</var>)</code>
 <dd>
-<code>inttypes.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>inttypes.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>imaxdiv_t</code>
 <dd>
-<code>inttypes.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>inttypes.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>struct in6_addr in6addr_any</code>
 <dd>
-<code>netinet/in.h</code> (IPv6 basic API):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (IPv6 basic API):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>struct in6_addr in6addr_loopback</code>
 <dd>
-<code>netinet/in.h</code> (IPv6 basic API):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (IPv6 basic API):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>uint32_t INADDR_ANY</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>uint32_t INADDR_BROADCAST</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>uint32_t INADDR_LOOPBACK</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>uint32_t INADDR_NONE</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>char * index (const char *<var>string</var>, int <var>c</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (BSD):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>uint32_t inet_addr (const char *<var>name</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (BSD):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (BSD):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>int inet_aton (const char *<var>name</var>, struct in_addr *<var>addr</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (BSD):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (BSD):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>uint32_t inet_lnaof (struct in_addr <var>addr</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (BSD):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (BSD):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>struct in_addr inet_makeaddr (uint32_t <var>net</var>, uint32_t <var>local</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (BSD):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (BSD):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>uint32_t inet_netof (struct in_addr <var>addr</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (BSD):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (BSD):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>uint32_t inet_network (const char *<var>name</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (BSD):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (BSD):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>char * inet_ntoa (struct in_addr <var>addr</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (BSD):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (BSD):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>const char * inet_ntop (int <var>af</var>, const void *<var>cp</var>, char *<var>buf</var>, size_t <var>len</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (IPv6 basic API):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (IPv6 basic API):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>int inet_pton (int <var>af</var>, const char *<var>cp</var>, void *<var>buf</var>)</code>
 <dd>
-<code>arpa/inet.h</code> (IPv6 basic API):  <a href="#Host%20Address%20Functions">Host Address Functions</a>.
+<code>arpa/inet.h</code> (IPv6 basic API):  <a href="#Host Address Functions">Host Address Functions</a>.
 
 <br><dt><code>float INFINITY</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Infinity%20and%20NaN">Infinity and NaN</a>.
+<code>math.h</code> (ISO):  <a href="#Infinity and NaN">Infinity and NaN</a>.
 
 <br><dt><code>int initgroups (const char *<var>user</var>, gid_t <var>group</var>)</code>
 <dd>
-<code>grp.h</code> (BSD):  <a href="#Setting%20Groups">Setting Groups</a>.
+<code>grp.h</code> (BSD):  <a href="#Setting Groups">Setting Groups</a>.
 
 <br><dt><code>INIT_PROCESS</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>INIT_PROCESS</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>void * initstate (unsigned int <var>seed</var>, void *<var>state</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (BSD):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>int initstate_r (unsigned int <var>seed</var>, char *restrict <var>statebuf</var>, size_t <var>statelen</var>, struct random_data *restrict <var>buf</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>tcflag_t INLCR</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>int innetgr (const char *<var>netgroup</var>, const char *<var>host</var>, const char *<var>user</var>, const char *<var>domain</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Netgroup%20Membership">Netgroup Membership</a>.
+<code>netdb.h</code> (BSD):  <a href="#Netgroup Membership">Netgroup Membership</a>.
 
 <br><dt><code>ino64_t</code>
 <dd>
-<code>sys/types.h</code> (Unix98):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/types.h</code> (Unix98):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>ino_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>tcflag_t INPCK</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>INT_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>INT_MIN</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>int ioctl (int <var>filedes</var>, int <var>command</var>, <small>...</small>)</code>
 <dd>
 <code>sys/ioctl.h</code> (BSD):  <a href="#IOCTLs">IOCTLs</a>.
 
 <br><dt><code>int _IOFBF</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (ISO):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>int _IOLBF</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (ISO):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>int _IONBF</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (ISO):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>int IPPORT_RESERVED</code>
 <dd>
 <code>netinet/in.h</code> (BSD):  <a href="#Ports">Ports</a>.
@@ -80712,1409 +79103,1409 @@
 <code>netinet/in.h</code> (BSD):  <a href="#Ports">Ports</a>.
 
 <br><dt><code>int isalnum (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isalpha (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isascii (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (SVID, BSD):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (SVID, BSD):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isatty (int <var>filedes</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Is It a Terminal">Is It a Terminal</a>.
 
 <br><dt><code>int isblank (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (GNU):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (GNU):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int iscntrl (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isdigit (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isfinite (<em>float-type</em> <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (ISO):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isgraph (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isgreater (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>.
+<code>math.h</code> (ISO):  <a href="#FP Comparison Functions">FP Comparison Functions</a>.
 
 <br><dt><code>int isgreaterequal (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>.
+<code>math.h</code> (ISO):  <a href="#FP Comparison Functions">FP Comparison Functions</a>.
 
 <br><dt><code>tcflag_t ISIG</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>int isinf (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isinff (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isinfl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isless (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>.
+<code>math.h</code> (ISO):  <a href="#FP Comparison Functions">FP Comparison Functions</a>.
 
 <br><dt><code>int islessequal (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>.
+<code>math.h</code> (ISO):  <a href="#FP Comparison Functions">FP Comparison Functions</a>.
 
 <br><dt><code>int islessgreater (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>.
+<code>math.h</code> (ISO):  <a href="#FP Comparison Functions">FP Comparison Functions</a>.
 
 <br><dt><code>int islower (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isnan (<em>float-type</em> <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (ISO):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isnan (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isnanf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isnanl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (BSD):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>int isnormal (<em>float-type</em> <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Floating%20Point%20Classes">Floating Point Classes</a>.
+<code>math.h</code> (ISO):  <a href="#Floating Point Classes">Floating Point Classes</a>.
 
 <br><dt><code>_ISOC99_SOURCE</code>
 <dd>
-(GNU):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(GNU):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>int isprint (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int ispunct (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int isspace (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>tcflag_t ISTRIP</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>int isunordered (<em>real-floating</em> <var>x</var>, <em>real-floating</em> <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>.
+<code>math.h</code> (ISO):  <a href="#FP Comparison Functions">FP Comparison Functions</a>.
 
 <br><dt><code>int isupper (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>int iswalnum (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswalpha (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswblank (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (GNU):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (GNU):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswcntrl (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswctype (wint_t <var>wc</var>, wctype_t <var>desc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswdigit (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswgraph (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswlower (wint_t <var>wc</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswprint (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswpunct (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswspace (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswupper (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int iswxdigit (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int isxdigit (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Classification%20of%20Characters">Classification of Characters</a>.
+<code>ctype.h</code> (ISO):  <a href="#Classification of Characters">Classification of Characters</a>.
 
 <br><dt><code>ITIMER_PROF</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<code>sys/time.h</code> (BSD):  <a href="#Setting an Alarm">Setting an Alarm</a>.
 
 <br><dt><code>ITIMER_REAL</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<code>sys/time.h</code> (BSD):  <a href="#Setting an Alarm">Setting an Alarm</a>.
 
 <br><dt><code>ITIMER_VIRTUAL</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<code>sys/time.h</code> (BSD):  <a href="#Setting an Alarm">Setting an Alarm</a>.
 
 <br><dt><code>tcflag_t IXANY</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>tcflag_t IXOFF</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>tcflag_t IXON</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>double j0 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float j0f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double j0l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>double j1 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float j1f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double j1l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>jmp_buf</code>
 <dd>
-<code>setjmp.h</code> (ISO):  <a href="#Non-Local%20Details">Non-Local Details</a>.
+<code>setjmp.h</code> (ISO):  <a href="#Non-Local Details">Non-Local Details</a>.
 
 <br><dt><code>double jn (int n, double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float jnf (int n, float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double jnl (int n, long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long int jrand48 (unsigned short int <var>xsubi</var>[3])</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int jrand48_r (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, long int *<var>result</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int kill (pid_t <var>pid</var>, int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Signaling%20Another%20Process">Signaling Another Process</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Signaling Another Process">Signaling Another Process</a>.
 
 <br><dt><code>int killpg (int <var>pgid</var>, int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Signaling%20Another%20Process">Signaling Another Process</a>.
+<code>signal.h</code> (BSD):  <a href="#Signaling Another Process">Signaling Another Process</a>.
 
 <br><dt><code>char * l64a (long int <var>n</var>)</code>
 <dd>
-<code>stdlib.h</code> (XPG):  <a href="#Encode%20Binary%20Data">Encode Binary Data</a>.
+<code>stdlib.h</code> (XPG):  <a href="#Encode Binary Data">Encode Binary Data</a>.
 
 <br><dt><code>long int labs (long int <var>number</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>LANG</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (ISO):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>LC_ALL</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (ISO):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>LC_COLLATE</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (ISO):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>LC_CTYPE</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (ISO):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>LC_MESSAGES</code>
 <dd>
-<code>locale.h</code> (XOPEN):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (XOPEN):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>LC_MONETARY</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (ISO):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>LC_NUMERIC</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (ISO):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>void lcong48 (unsigned short int <var>param</var>[7])</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int lcong48_r (unsigned short int <var>param</var>[7], struct drand48_data *<var>buffer</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int L_ctermid</code>
 <dd>
-<code>stdio.h</code> (POSIX.1):  <a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>.
+<code>stdio.h</code> (POSIX.1):  <a href="#Identifying the Terminal">Identifying the Terminal</a>.
 
 <br><dt><code>LC_TIME</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Locale%20Categories">Locale Categories</a>.
+<code>locale.h</code> (ISO):  <a href="#Locale Categories">Locale Categories</a>.
 
 <br><dt><code>int L_cuserid</code>
 <dd>
-<code>stdio.h</code> (POSIX.1):  <a href="#Who%20Logged%20In">Who Logged In</a>.
+<code>stdio.h</code> (POSIX.1):  <a href="#Who Logged In">Who Logged In</a>.
 
 <br><dt><code>double ldexp (double <var>value</var>, int <var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>float ldexpf (float <var>value</var>, int <var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long double ldexpl (long double <var>value</var>, int <var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>ldiv_t ldiv (long int <var>numerator</var>, long int <var>denominator</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>ldiv_t</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>void * lfind (const void *<var>key</var>, void *<var>base</var>, size_t *<var>nmemb</var>, size_t <var>size</var>, comparison_fn_t <var>compar</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Array%20Search%20Function">Array Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Array Search Function">Array Search Function</a>.
 
 <br><dt><code>double lgamma (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float lgammaf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float lgammaf_r (float <var>x</var>, int *<var>signp</var>)</code>
 <dd>
-<code>math.h</code> (XPG):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (XPG):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double lgammal (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double lgammal_r (long double <var>x</var>, int *<var>signp</var>)</code>
 <dd>
-<code>math.h</code> (XPG):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (XPG):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>double lgamma_r (double <var>x</var>, int *<var>signp</var>)</code>
 <dd>
-<code>math.h</code> (XPG):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (XPG):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>L_INCR</code>
 <dd>
-<code>sys/file.h</code> (BSD):  <a href="#File%20Positioning">File Positioning</a>.
+<code>sys/file.h</code> (BSD):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int LINE_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Limits">Utility Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Limits">Utility Limits</a>.
 
 <br><dt><code>int link (const char *<var>oldname</var>, const char *<var>newname</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Hard%20Links">Hard Links</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Hard Links">Hard Links</a>.
 
 <br><dt><code>int LINK_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>int lio_listio (int <var>mode</var>, struct aiocb *const <var>list</var>[], int <var>nent</var>, struct sigevent *<var>sig</var>)</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>.
 
 <br><dt><code>int lio_listio64 (int <var>mode</var>, struct aiocb *const <var>list</var>, int <var>nent</var>, struct sigevent *<var>sig</var>)</code>
 <dd>
-<code>aio.h</code> (Unix98):  <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>.
+<code>aio.h</code> (Unix98):  <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>.
 
 <br><dt><code>int listen (int <var>socket</var>, unsigned int <var>n</var>)</code>
 <dd>
 <code>sys/socket.h</code> (BSD):  <a href="#Listening">Listening</a>.
 
 <br><dt><code>long long int llabs (long long int <var>number</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Absolute%20Value">Absolute Value</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Absolute Value">Absolute Value</a>.
 
 <br><dt><code>lldiv_t lldiv (long long int <var>numerator</var>, long long int <var>denominator</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>lldiv_t</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Integer%20Division">Integer Division</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Integer Division">Integer Division</a>.
 
 <br><dt><code>long long int llrint (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long long int llrintf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long long int llrintl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long long int llround (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long long int llroundf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long long int llroundl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>struct lconv * localeconv (void)</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>.
+<code>locale.h</code> (ISO):  <a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>.
 
 <br><dt><code>struct tm * localtime (const time_t *<var>time</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (ISO):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>struct tm * localtime_r (const time_t *<var>time</var>, struct tm *<var>resultp</var>)</code>
 <dd>
-<code>time.h</code> (POSIX.1c):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (POSIX.1c):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>double log (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double log10 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float log10f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double log10l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double log1p (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float log1pf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double log1pl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double log2 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float log2f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double log2l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double logb (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float logbf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double logbl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float logf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>void login (const struct utmp *<var>entry</var>)</code>
 <dd>
-<code>utmp.h</code> (BSD):  <a href="#Logging%20In%20and%20Out">Logging In and Out</a>.
+<code>utmp.h</code> (BSD):  <a href="#Logging In and Out">Logging In and Out</a>.
 
 <br><dt><code>LOGIN_PROCESS</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>LOGIN_PROCESS</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int login_tty (int <var>filedes</var>)</code>
 <dd>
-<code>utmp.h</code> (BSD):  <a href="#Logging%20In%20and%20Out">Logging In and Out</a>.
+<code>utmp.h</code> (BSD):  <a href="#Logging In and Out">Logging In and Out</a>.
 
 <br><dt><code>long double logl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>int logout (const char *<var>ut_line</var>)</code>
 <dd>
-<code>utmp.h</code> (BSD):  <a href="#Logging%20In%20and%20Out">Logging In and Out</a>.
+<code>utmp.h</code> (BSD):  <a href="#Logging In and Out">Logging In and Out</a>.
 
 <br><dt><code>void logwtmp (const char *<var>ut_line</var>, const char *<var>ut_name</var>, const char *<var>ut_host</var>)</code>
 <dd>
-<code>utmp.h</code> (BSD):  <a href="#Logging%20In%20and%20Out">Logging In and Out</a>.
+<code>utmp.h</code> (BSD):  <a href="#Logging In and Out">Logging In and Out</a>.
 
 <br><dt><code>void longjmp (jmp_buf <var>state</var>, int <var>value</var>)</code>
 <dd>
-<code>setjmp.h</code> (ISO):  <a href="#Non-Local%20Details">Non-Local Details</a>.
+<code>setjmp.h</code> (ISO):  <a href="#Non-Local Details">Non-Local Details</a>.
 
 <br><dt><code>LONG_LONG_MAX</code>
 <dd>
-<code>limits.h</code> (GNU):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (GNU):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>LONG_LONG_MIN</code>
 <dd>
-<code>limits.h</code> (GNU):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (GNU):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>LONG_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>LONG_MIN</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>long int lrand48 (void)</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int lrand48_r (struct drand48_data *<var>buffer</var>, double *<var>result</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>long int lrint (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long int lrintf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long int lrintl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long int lround (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long int lroundf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long int lroundl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>void * lsearch (const void *<var>key</var>, void *<var>base</var>, size_t *<var>nmemb</var>, size_t <var>size</var>, comparison_fn_t <var>compar</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Array%20Search%20Function">Array Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Array Search Function">Array Search Function</a>.
 
 <br><dt><code>off_t lseek (int <var>filedes</var>, off_t <var>offset</var>, int <var>whence</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#File%20Position%20Primitive">File Position Primitive</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#File Position Primitive">File Position Primitive</a>.
 
 <br><dt><code>off64_t lseek64 (int <var>filedes</var>, off64_t <var>offset</var>, int <var>whence</var>)</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#File%20Position%20Primitive">File Position Primitive</a>.
+<code>unistd.h</code> (Unix98):  <a href="#File Position Primitive">File Position Primitive</a>.
 
 <br><dt><code>L_SET</code>
 <dd>
-<code>sys/file.h</code> (BSD):  <a href="#File%20Positioning">File Positioning</a>.
+<code>sys/file.h</code> (BSD):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int lstat (const char *<var>filename</var>, struct stat *<var>buf</var>)</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Reading%20Attributes">Reading Attributes</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Reading Attributes">Reading Attributes</a>.
 
 <br><dt><code>int lstat64 (const char *<var>filename</var>, struct stat64 *<var>buf</var>)</code>
 <dd>
-<code>sys/stat.h</code> (Unix98):  <a href="#Reading%20Attributes">Reading Attributes</a>.
+<code>sys/stat.h</code> (Unix98):  <a href="#Reading Attributes">Reading Attributes</a>.
 
 <br><dt><code>int L_tmpnam</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (ISO):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>L_XTND</code>
 <dd>
-<code>sys/file.h</code> (BSD):  <a href="#File%20Positioning">File Positioning</a>.
+<code>sys/file.h</code> (BSD):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int madvise (void *<var>addr</var>, size_t <var>length</var>, int <var>advice</var>)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <br><dt><code>void makecontext (ucontext_t *<var>ucp</var>, void (*<var>func</var>) (void), int <var>argc</var>, <small>...</small>)</code>
 <dd>
-<code>ucontext.h</code> (SVID):  <a href="#System%20V%20contexts">System V contexts</a>.
+<code>ucontext.h</code> (SVID):  <a href="#System V contexts">System V contexts</a>.
 
 <br><dt><code>struct mallinfo mallinfo (void)</code>
 <dd>
-<code>malloc.h</code> (SVID):  <a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>.
+<code>malloc.h</code> (SVID):  <a href="#Statistics of Malloc">Statistics of Malloc</a>.
 
 <br><dt><code>void * malloc (size_t <var>size</var>)</code>
 <dd>
-<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Basic%20Allocation">Basic Allocation</a>.
+<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Basic Allocation">Basic Allocation</a>.
 
 <br><dt><code>__malloc_hook</code>
 <dd>
-<code>malloc.h</code> (GNU):  <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>.
+<code>malloc.h</code> (GNU):  <a href="#Hooks for Malloc">Hooks for Malloc</a>.
 
 <br><dt><code>__malloc_initialize_hook</code>
 <dd>
-<code>malloc.h</code> (GNU):  <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>.
+<code>malloc.h</code> (GNU):  <a href="#Hooks for Malloc">Hooks for Malloc</a>.
 
 <br><dt><code>int MAX_CANON</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>int MAX_INPUT</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>int MAXNAMLEN</code>
 <dd>
-<code>dirent.h</code> (BSD):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>dirent.h</code> (BSD):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>int MAXSYMLINKS</code>
 <dd>
-<code>sys/param.h</code> (BSD):  <a href="#Symbolic%20Links">Symbolic Links</a>.
+<code>sys/param.h</code> (BSD):  <a href="#Symbolic Links">Symbolic Links</a>.
 
 <br><dt><code>int MB_CUR_MAX</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Selecting%20the%20Conversion">Selecting the Conversion</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Selecting the Conversion">Selecting the Conversion</a>.
 
 <br><dt><code>int mblen (const char *<var>string</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>.
 
 <br><dt><code>int MB_LEN_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Selecting%20the%20Conversion">Selecting the Conversion</a>.
+<code>limits.h</code> (ISO):  <a href="#Selecting the Conversion">Selecting the Conversion</a>.
 
 <br><dt><code>size_t mbrlen (const char *restrict <var>s</var>, size_t <var>n</var>, mbstate_t *<var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Converting%20a%20Character">Converting a Character</a>.
+<code>wchar.h</code> (ISO):  <a href="#Converting a Character">Converting a Character</a>.
 
 <br><dt><code>size_t mbrtowc (wchar_t *restrict <var>pwc</var>, const char *restrict <var>s</var>, size_t <var>n</var>, mbstate_t *restrict <var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Converting%20a%20Character">Converting a Character</a>.
+<code>wchar.h</code> (ISO):  <a href="#Converting a Character">Converting a Character</a>.
 
 <br><dt><code>int mbsinit (const mbstate_t *<var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Keeping%20the%20state">Keeping the state</a>.
+<code>wchar.h</code> (ISO):  <a href="#Keeping the state">Keeping the state</a>.
 
 <br><dt><code>size_t mbsnrtowcs (wchar_t *restrict <var>dst</var>, const char **restrict <var>src</var>, size_t <var>nmc</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Converting%20Strings">Converting Strings</a>.
+<code>wchar.h</code> (GNU):  <a href="#Converting Strings">Converting Strings</a>.
 
 <br><dt><code>size_t mbsrtowcs (wchar_t *restrict <var>dst</var>, const char **restrict <var>src</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Converting%20Strings">Converting Strings</a>.
+<code>wchar.h</code> (ISO):  <a href="#Converting Strings">Converting Strings</a>.
 
 <br><dt><code>mbstate_t</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Keeping%20the%20state">Keeping the state</a>.
+<code>wchar.h</code> (ISO):  <a href="#Keeping the state">Keeping the state</a>.
 
 <br><dt><code>size_t mbstowcs (wchar_t *<var>wstring</var>, const char *<var>string</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>.
 
 <br><dt><code>int mbtowc (wchar_t *restrict <var>result</var>, const char *restrict <var>string</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>.
 
 <br><dt><code>int mcheck (void (*<var>abortfn</var>) (enum mcheck_status <var>status</var>))</code>
 <dd>
-<code>mcheck.h</code> (GNU):  <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>.
+<code>mcheck.h</code> (GNU):  <a href="#Heap Consistency Checking">Heap Consistency Checking</a>.
 
 <br><dt><code>tcflag_t MDMBUF</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>void * memalign (size_t <var>boundary</var>, size_t <var>size</var>)</code>
 <dd>
-<code>malloc.h</code>, <code>stdlib.h</code> (BSD):  <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>.
+<code>malloc.h</code>, <code>stdlib.h</code> (BSD):  <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>.
 
 <br><dt><code>__memalign_hook</code>
 <dd>
-<code>malloc.h</code> (GNU):  <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>.
+<code>malloc.h</code> (GNU):  <a href="#Hooks for Malloc">Hooks for Malloc</a>.
 
 <br><dt><code>void * memccpy (void *restrict <var>to</var>, const void *restrict <var>from</var>, int <var>c</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (SVID):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (SVID):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>void * memchr (const void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>int memcmp (const void *<var>a1</var>, const void *<var>a2</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>string.h</code> (ISO):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>void * memcpy (void *restrict <var>to</var>, const void *restrict <var>from</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>void * memfrob (void *<var>mem</var>, size_t <var>length</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Trivial%20Encryption">Trivial Encryption</a>.
+<code>string.h</code> (GNU):  <a href="#Trivial Encryption">Trivial Encryption</a>.
 
 <br><dt><code>void * memmem (const void *<var>haystack</var>, size_t <var>haystack-len</var>,<br>const void *<var>needle</var>, size_t <var>needle-len</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (GNU):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>void * memmove (void *<var>to</var>, const void *<var>from</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>void * mempcpy (void *restrict <var>to</var>, const void *restrict <var>from</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>void * memrchr (const void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (GNU):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>void * memset (void *<var>block</var>, int <var>c</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>int mkdir (const char *<var>filename</var>, mode_t <var>mode</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Creating%20Directories">Creating Directories</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Creating Directories">Creating Directories</a>.
 
 <br><dt><code>char * mkdtemp (char *<var>template</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdlib.h</code> (BSD):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>int mkfifo (const char *<var>filename</var>, mode_t <var>mode</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#FIFO%20Special%20Files">FIFO Special Files</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#FIFO Special Files">FIFO Special Files</a>.
 
 <br><dt><code>int mknod (const char *<var>filename</var>, int <var>mode</var>, int <var>dev</var>)</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Making%20Special%20Files">Making Special Files</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Making Special Files">Making Special Files</a>.
 
 <br><dt><code>int mkstemp (char *<var>template</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdlib.h</code> (BSD):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>char * mktemp (char *<var>template</var>)</code>
 <dd>
-<code>stdlib.h</code> (Unix):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdlib.h</code> (Unix):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>time_t mktime (struct tm *<var>brokentime</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (ISO):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>int mlock (const void *<var>addr</var>, size_t <var>len</var>)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page%20Lock%20Functions">Page Lock Functions</a>.
+<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page Lock Functions">Page Lock Functions</a>.
 
 <br><dt><code>int mlockall (int <var>flags</var>)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page%20Lock%20Functions">Page Lock Functions</a>.
+<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page Lock Functions">Page Lock Functions</a>.
 
 <br><dt><code>void * mmap (void *<var>address</var>, size_t <var>length</var>,int <var>protect</var>, int <var>flags</var>, int <var>filedes</var>, off_t <var>offset</var>)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <br><dt><code>void * mmap64 (void *<var>address</var>, size_t <var>length</var>,int <var>protect</var>, int <var>flags</var>, int <var>filedes</var>, off64_t <var>offset</var>)</code>
 <dd>
-<code>sys/mman.h</code> (LFS):  <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+<code>sys/mman.h</code> (LFS):  <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <br><dt><code>mode_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>double modf (double <var>value</var>, double *<var>integer-part</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>float modff (float <var>value</var>, float *<var>integer-part</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long double modfl (long double <var>value</var>, long double *<var>integer-part</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>int mount (const char *<var>special_file</var>, const char *<var>dir</var>, const char *<var>fstype</var>, unsigned long int <var>options</var>, const void *<var>data</var>)</code>
 <dd>
 <code>sys/mount.h</code> (SVID, BSD):  <a href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>.
 
 <br><dt><code>long int mrand48 (void)</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int mrand48_r (struct drand48_data *<var>buffer</var>, double *<var>result</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>void * mremap (void *<var>address</var>, size_t <var>length</var>, size_t <var>new_length</var>, int <var>flag</var>)</code>
 <dd>
-<code>sys/mman.h</code> (GNU):  <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+<code>sys/mman.h</code> (GNU):  <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <br><dt><code>int MSG_DONTROUTE</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket%20Data%20Options">Socket Data Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket Data Options">Socket Data Options</a>.
 
 <br><dt><code>int MSG_OOB</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket%20Data%20Options">Socket Data Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket Data Options">Socket Data Options</a>.
 
 <br><dt><code>int MSG_PEEK</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket%20Data%20Options">Socket Data Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket Data Options">Socket Data Options</a>.
 
 <br><dt><code>int msync (void *<var>address</var>, size_t <var>length</var>, int <var>flags</var>)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <br><dt><code>void mtrace (void)</code>
 <dd>
-<code>mcheck.h</code> (GNU):  <a href="#Tracing%20malloc">Tracing malloc</a>.
+<code>mcheck.h</code> (GNU):  <a href="#Tracing malloc">Tracing malloc</a>.
 
 <br><dt><code>int munlock (const void *<var>addr</var>, size_t <var>len</var>)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page%20Lock%20Functions">Page Lock Functions</a>.
+<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page Lock Functions">Page Lock Functions</a>.
 
 <br><dt><code>int munlockall (void)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page%20Lock%20Functions">Page Lock Functions</a>.
+<code>sys/mman.h</code> (POSIX.1b):  <a href="#Page Lock Functions">Page Lock Functions</a>.
 
 <br><dt><code>int munmap (void *<var>addr</var>, size_t <var>length</var>)</code>
 <dd>
-<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>.
+<code>sys/mman.h</code> (POSIX):  <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>.
 
 <br><dt><code>void muntrace (void)</code>
 <dd>
-<code>mcheck.h</code> (GNU):  <a href="#Tracing%20malloc">Tracing malloc</a>.
+<code>mcheck.h</code> (GNU):  <a href="#Tracing malloc">Tracing malloc</a>.
 
 <br><dt><code>int NAME_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>float NAN</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Infinity%20and%20NaN">Infinity and NaN</a>.
+<code>math.h</code> (GNU):  <a href="#Infinity and NaN">Infinity and NaN</a>.
 
 <br><dt><code>double nan (const char *<var>tagp</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>float nanf (const char *<var>tagp</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>long double nanl (const char *<var>tagp</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>int nanosleep (const struct timespec *<var>requested_time</var>, struct timespec *<var>remaining</var>)</code>
 <dd>
 <code>time.h</code> (POSIX.1):  <a href="#Sleeping">Sleeping</a>.
 
 <br><dt><code>int NCCS</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Data%20Types">Mode Data Types</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Data Types">Mode Data Types</a>.
 
 <br><dt><code>double nearbyint (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>float nearbyintf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long double nearbyintl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>NEW_TIME</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>NEW_TIME</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>double nextafter (double <var>x</var>, double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>float nextafterf (float <var>x</var>, float <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>long double nextafterl (long double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>double nexttoward (double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>float nexttowardf (float <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>long double nexttowardl (long double <var>x</var>, long double <var>y</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>int nftw (const char *<var>filename</var>, __nftw_func_t <var>func</var>, int <var>descriptors</var>, int <var>flag</var>)</code>
 <dd>
-<code>ftw.h</code> (XPG4.2):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (XPG4.2):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>int nftw64 (const char *<var>filename</var>, __nftw64_func_t <var>func</var>, int <var>descriptors</var>, int <var>flag</var>)</code>
 <dd>
-<code>ftw.h</code> (Unix98):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (Unix98):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>__nftw64_func_t</code>
 <dd>
-<code>ftw.h</code> (GNU):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (GNU):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>__nftw_func_t</code>
 <dd>
-<code>ftw.h</code> (GNU):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (GNU):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>char * ngettext (const char *<var>msgid1</var>, const char *<var>msgid2</var>, unsigned long int <var>n</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Advanced%20gettext%20functions">Advanced gettext functions</a>.
+<code>libintl.h</code> (GNU):  <a href="#Advanced gettext functions">Advanced gettext functions</a>.
 
 <br><dt><code>int NGROUPS_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>int nice (int <var>increment</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>unistd.h</code> (BSD):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>nlink_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>char * nl_langinfo (nl_item <var>item</var>)</code>
 <dd>
-<code>langinfo.h</code> (XOPEN):  <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>.
+<code>langinfo.h</code> (XOPEN):  <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>.
 
 <br><dt><code>NO_ADDRESS</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>tcflag_t NOFLSH</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>tcflag_t NOKERNINFO</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>NO_RECOVERY</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>long int nrand48 (unsigned short int <var>xsubi</var>[3])</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int nrand48_r (unsigned short int <var>xsubi</var>[3], struct drand48_data *<var>buffer</var>, long int *<var>result</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int NSIG</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Standard%20Signals">Standard Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Standard Signals">Standard Signals</a>.
 
 <br><dt><code>uint32_t ntohl (uint32_t <var>netlong</var>)</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Byte%20Order">Byte Order</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Byte Order">Byte Order</a>.
 
 <br><dt><code>uint16_t ntohs (uint16_t <var>netshort</var>)</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Byte%20Order">Byte Order</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Byte Order">Byte Order</a>.
 
 <br><dt><code>int ntp_adjtime (struct timex *<var>tptr</var>)</code>
 <dd>
-<code>sys/timex.h</code> (GNU):  <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>.
+<code>sys/timex.h</code> (GNU):  <a href="#High Accuracy Clock">High Accuracy Clock</a>.
 
 <br><dt><code>int ntp_gettime (struct ntptimeval *<var>tptr</var>)</code>
 <dd>
-<code>sys/timex.h</code> (GNU):  <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>.
+<code>sys/timex.h</code> (GNU):  <a href="#High Accuracy Clock">High Accuracy Clock</a>.
 
 <br><dt><code>void * NULL</code>
 <dd>
-<code>stddef.h</code> (ISO):  <a href="#Null%20Pointer%20Constant">Null Pointer Constant</a>.
+<code>stddef.h</code> (ISO):  <a href="#Null Pointer Constant">Null Pointer Constant</a>.
 
 <br><dt><code>int O_ACCMODE</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Access%20Modes">Access Modes</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Access Modes">Access Modes</a>.
 
 <br><dt><code>int O_APPEND</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Operating%20Modes">Operating Modes</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Operating Modes">Operating Modes</a>.
 
 <br><dt><code>int O_ASYNC</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Operating%20Modes">Operating Modes</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Operating Modes">Operating Modes</a>.
 
 <br><dt><code>void obstack_1grow (struct obstack *<var>obstack-ptr</var>, char <var>c</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_1grow_fast (struct obstack *<var>obstack-ptr</var>, char <var>c</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+<code>obstack.h</code> (GNU):  <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>int obstack_alignment_mask (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>.
+<code>obstack.h</code> (GNU):  <a href="#Obstacks Data Alignment">Obstacks Data Alignment</a>.
 
 <br><dt><code>void * obstack_alloc (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>.
+<code>obstack.h</code> (GNU):  <a href="#Allocation in an Obstack">Allocation in an Obstack</a>.
 
 <br><dt><code>obstack_alloc_failed_handler</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>.
+<code>obstack.h</code> (GNU):  <a href="#Preparing for Obstacks">Preparing for Obstacks</a>.
 
 <br><dt><code>void * obstack_base (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>.
+<code>obstack.h</code> (GNU):  <a href="#Status of an Obstack">Status of an Obstack</a>.
 
 <br><dt><code>void obstack_blank (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_blank_fast (struct obstack *<var>obstack-ptr</var>, int <var>size</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+<code>obstack.h</code> (GNU):  <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>int obstack_chunk_size (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Obstack%20Chunks">Obstack Chunks</a>.
+<code>obstack.h</code> (GNU):  <a href="#Obstack Chunks">Obstack Chunks</a>.
 
 <br><dt><code>void * obstack_copy (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>.
+<code>obstack.h</code> (GNU):  <a href="#Allocation in an Obstack">Allocation in an Obstack</a>.
 
 <br><dt><code>void * obstack_copy0 (struct obstack *<var>obstack-ptr</var>, void *<var>address</var>, int <var>size</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>.
+<code>obstack.h</code> (GNU):  <a href="#Allocation in an Obstack">Allocation in an Obstack</a>.
 
 <br><dt><code>void * obstack_finish (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_free (struct obstack *<var>obstack-ptr</var>, void *<var>object</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Freeing Obstack Objects">Freeing Obstack Objects</a>.
 
 <br><dt><code>void obstack_grow (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>, int <var>size</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_grow0 (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>, int <var>size</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>int obstack_init (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>.
+<code>obstack.h</code> (GNU):  <a href="#Preparing for Obstacks">Preparing for Obstacks</a>.
 
 <br><dt><code>void obstack_int_grow (struct obstack *<var>obstack-ptr</var>, int <var>data</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_int_grow_fast (struct obstack *<var>obstack-ptr</var>, int <var>data</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+<code>obstack.h</code> (GNU):  <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>void * obstack_next_free (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>.
+<code>obstack.h</code> (GNU):  <a href="#Status of an Obstack">Status of an Obstack</a>.
 
 <br><dt><code>int obstack_object_size (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>int obstack_object_size (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>.
+<code>obstack.h</code> (GNU):  <a href="#Status of an Obstack">Status of an Obstack</a>.
 
 <br><dt><code>int obstack_printf (struct obstack *<var>obstack</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Dynamic%20Output">Dynamic Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Dynamic Output">Dynamic Output</a>.
 
 <br><dt><code>void obstack_ptr_grow (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Growing%20Objects">Growing Objects</a>.
+<code>obstack.h</code> (GNU):  <a href="#Growing Objects">Growing Objects</a>.
 
 <br><dt><code>void obstack_ptr_grow_fast (struct obstack *<var>obstack-ptr</var>, void *<var>data</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+<code>obstack.h</code> (GNU):  <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>int obstack_room (struct obstack *<var>obstack-ptr</var>)</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>.
+<code>obstack.h</code> (GNU):  <a href="#Extra Fast Growing">Extra Fast Growing</a>.
 
 <br><dt><code>int obstack_vprintf (struct obstack *<var>obstack</var>, const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int O_CREAT</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>int O_EXCL</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>int O_EXEC</code>
 <dd>
-<code>fcntl.h</code> (GNU):  <a href="#Access%20Modes">Access Modes</a>.
+<code>fcntl.h</code> (GNU):  <a href="#Access Modes">Access Modes</a>.
 
 <br><dt><code>int O_EXLOCK</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>off64_t</code>
 <dd>
-<code>sys/types.h</code> (Unix98):  <a href="#File%20Position%20Primitive">File Position Primitive</a>.
+<code>sys/types.h</code> (Unix98):  <a href="#File Position Primitive">File Position Primitive</a>.
 
 <br><dt><code>size_t offsetof (<var>type</var>, <var>member</var>)</code>
 <dd>
-<code>stddef.h</code> (ISO):  <a href="#Structure%20Measurement">Structure Measurement</a>.
+<code>stddef.h</code> (ISO):  <a href="#Structure Measurement">Structure Measurement</a>.
 
 <br><dt><code>off_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#File%20Position%20Primitive">File Position Primitive</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#File Position Primitive">File Position Primitive</a>.
 
 <br><dt><code>int O_FSYNC</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Operating%20Modes">Operating Modes</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Operating Modes">Operating Modes</a>.
 
 <br><dt><code>int O_IGNORE_CTTY</code>
 <dd>
-<code>fcntl.h</code> (GNU):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (GNU):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>OLD_TIME</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>OLD_TIME</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int O_NDELAY</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Operating%20Modes">Operating Modes</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Operating Modes">Operating Modes</a>.
 
 <br><dt><code>int on_exit (void (*<var>function</var>)(int <var>status</var>, void *<var>arg</var>), void *<var>arg</var>)</code>
 <dd>
-<code>stdlib.h</code> (SunOS):  <a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>.
+<code>stdlib.h</code> (SunOS):  <a href="#Cleanups on Exit">Cleanups on Exit</a>.
 
 <br><dt><code>tcflag_t ONLCR</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Output%20Modes">Output Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Output Modes">Output Modes</a>.
 
 <br><dt><code>int O_NOATIME</code>
 <dd>
-<code>fcntl.h</code> (GNU):  <a href="#Operating%20Modes">Operating Modes</a>.
+<code>fcntl.h</code> (GNU):  <a href="#Operating Modes">Operating Modes</a>.
 
 <br><dt><code>int O_NOCTTY</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>tcflag_t ONOEOT</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Output%20Modes">Output Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Output Modes">Output Modes</a>.
 
 <br><dt><code>int O_NOLINK</code>
 <dd>
-<code>fcntl.h</code> (GNU):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (GNU):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>int O_NONBLOCK</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>int O_NONBLOCK</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Operating%20Modes">Operating Modes</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Operating Modes">Operating Modes</a>.
 
 <br><dt><code>int O_NOTRANS</code>
 <dd>
-<code>fcntl.h</code> (GNU):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (GNU):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>int open (const char *<var>filename</var>, int <var>flags</var>[, mode_t <var>mode</var>])</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Opening and Closing Files">Opening and Closing Files</a>.
 
 <br><dt><code>int open64 (const char *<var>filename</var>, int <var>flags</var>[, mode_t <var>mode</var>])</code>
 <dd>
-<code>fcntl.h</code> (Unix98):  <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>.
+<code>fcntl.h</code> (Unix98):  <a href="#Opening and Closing Files">Opening and Closing Files</a>.
 
 <br><dt><code>DIR * opendir (const char *<var>dirname</var>)</code>
 <dd>
-<code>dirent.h</code> (POSIX.1):  <a href="#Opening%20a%20Directory">Opening a Directory</a>.
+<code>dirent.h</code> (POSIX.1):  <a href="#Opening a Directory">Opening a Directory</a>.
 
 <br><dt><code>void openlog (char *<var>ident</var>, int <var>option</var>,</code>
 <dd>
 <code>syslog.h</code> (BSD):  <a href="#openlog">openlog</a>.
 
 <br><dt><code>int OPEN_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>FILE * open_memstream (char **<var>ptr</var>, size_t *<var>sizeloc</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#String%20Streams">String Streams</a>.
+<code>stdio.h</code> (GNU):  <a href="#String Streams">String Streams</a>.
 
 <br><dt><code>FILE * open_obstack_stream (struct obstack *<var>obstack</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Obstack%20Streams">Obstack Streams</a>.
+<code>stdio.h</code> (GNU):  <a href="#Obstack Streams">Obstack Streams</a>.
 
 <br><dt><code>int openpty (int *<var>amaster</var>, int *<var>aslave</var>, char *<var>name</var>, struct termios *<var>termp</var>, struct winsize *<var>winp</var>)</code>
 <dd>
-<code>pty.h</code> (BSD):  <a href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>.
+<code>pty.h</code> (BSD):  <a href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>.
 
 <br><dt><code>tcflag_t OPOST</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Output%20Modes">Output Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Output Modes">Output Modes</a>.
 
 <br><dt><code>char * optarg</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Using%20Getopt">Using Getopt</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Using Getopt">Using Getopt</a>.
 
 <br><dt><code>int opterr</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Using%20Getopt">Using Getopt</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Using Getopt">Using Getopt</a>.
 
 <br><dt><code>int optind</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Using%20Getopt">Using Getopt</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Using Getopt">Using Getopt</a>.
 
 <br><dt><code>OPTION_ALIAS</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Option%20Flags">Argp Option Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Option Flags">Argp Option Flags</a>.
 
 <br><dt><code>OPTION_ARG_OPTIONAL</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Option%20Flags">Argp Option Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Option Flags">Argp Option Flags</a>.
 
 <br><dt><code>OPTION_DOC</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Option%20Flags">Argp Option Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Option Flags">Argp Option Flags</a>.
 
 <br><dt><code>OPTION_HIDDEN</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Option%20Flags">Argp Option Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Option Flags">Argp Option Flags</a>.
 
 <br><dt><code>OPTION_NO_USAGE</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Option%20Flags">Argp Option Flags</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Option Flags">Argp Option Flags</a>.
 
 <br><dt><code>int optopt</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Using%20Getopt">Using Getopt</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Using Getopt">Using Getopt</a>.
 
 <br><dt><code>int O_RDONLY</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Access%20Modes">Access Modes</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Access Modes">Access Modes</a>.
 
 <br><dt><code>int O_RDWR</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Access%20Modes">Access Modes</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Access Modes">Access Modes</a>.
 
 <br><dt><code>int O_READ</code>
 <dd>
-<code>fcntl.h</code> (GNU):  <a href="#Access%20Modes">Access Modes</a>.
+<code>fcntl.h</code> (GNU):  <a href="#Access Modes">Access Modes</a>.
 
 <br><dt><code>int O_SHLOCK</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>int O_SYNC</code>
 <dd>
-<code>fcntl.h</code> (BSD):  <a href="#Operating%20Modes">Operating Modes</a>.
+<code>fcntl.h</code> (BSD):  <a href="#Operating Modes">Operating Modes</a>.
 
 <br><dt><code>int O_TRUNC</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time%20Flags">Open-time Flags</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Open-time Flags">Open-time Flags</a>.
 
 <br><dt><code>int O_WRITE</code>
 <dd>
-<code>fcntl.h</code> (GNU):  <a href="#Access%20Modes">Access Modes</a>.
+<code>fcntl.h</code> (GNU):  <a href="#Access Modes">Access Modes</a>.
 
 <br><dt><code>int O_WRONLY</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#Access%20Modes">Access Modes</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#Access Modes">Access Modes</a>.
 
 <br><dt><code>tcflag_t OXTABS</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Output%20Modes">Output Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Output Modes">Output Modes</a>.
 
 <br><dt><code>PA_CHAR</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_DOUBLE</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_FLAG_LONG</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_FLAG_LONG_DOUBLE</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_FLAG_LONG_LONG</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>int PA_FLAG_MASK</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_FLAG_PTR</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_FLAG_SHORT</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_FLOAT</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_INT</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_LAST</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_POINTER</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>tcflag_t PARENB</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>tcflag_t PARMRK</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Input%20Modes">Input Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Input Modes">Input Modes</a>.
 
 <br><dt><code>tcflag_t PARODD</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Control%20Modes">Control Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Control Modes">Control Modes</a>.
 
 <br><dt><code>size_t parse_printf_format (const char *<var>template</var>, size_t <var>n</var>, int *<var>argtypes</var>)</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>PA_STRING</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>.
+<code>printf.h</code> (GNU):  <a href="#Parsing a Template String">Parsing a Template String</a>.
 
 <br><dt><code>long int pathconf (const char *<var>filename</var>, int <var>parameter</var>)</code>
 <dd>
 <code>unistd.h</code> (POSIX.1):  <a href="#Pathconf">Pathconf</a>.
 
 <br><dt><code>int PATH_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>int pause ()</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Using%20Pause">Using Pause</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Using Pause">Using Pause</a>.
 
 <br><dt><code>_PC_ASYNC_IO</code>
 <dd>
 <code>unistd.h</code> (POSIX.1):  <a href="#Pathconf">Pathconf</a>.
@@ -82132,9 +80523,9 @@
 <code>unistd.h</code> (POSIX.1):  <a href="#Pathconf">Pathconf</a>.
 
 <br><dt><code>int pclose (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX.2, SVID, BSD):  <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>.
+<code>stdio.h</code> (POSIX.2, SVID, BSD):  <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>.
 
 <br><dt><code>_PC_MAX_CANON</code>
 <dd>
 <code>unistd.h</code> (POSIX.1):  <a href="#Pathconf">Pathconf</a>.
@@ -82192,109 +80583,109 @@
 <code>unistd.h</code> (POSIX.1):  <a href="#Pathconf">Pathconf</a>.
 
 <br><dt><code>tcflag_t PENDIN</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>void perror (const char *<var>message</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Error%20Messages">Error Messages</a>.
+<code>stdio.h</code> (ISO):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>int PF_FILE</code>
 <dd>
-<code>sys/socket.h</code> (GNU):  <a href="#Local%20Namespace%20Details">Local Namespace Details</a>.
+<code>sys/socket.h</code> (GNU):  <a href="#Local Namespace Details">Local Namespace Details</a>.
 
 <br><dt><code>int PF_INET</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Internet%20Namespace">Internet Namespace</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Internet Namespace">Internet Namespace</a>.
 
 <br><dt><code>int PF_INET6</code>
 <dd>
-<code>sys/socket.h</code> (X/Open):  <a href="#Internet%20Namespace">Internet Namespace</a>.
+<code>sys/socket.h</code> (X/Open):  <a href="#Internet Namespace">Internet Namespace</a>.
 
 <br><dt><code>int PF_LOCAL</code>
 <dd>
-<code>sys/socket.h</code> (POSIX):  <a href="#Local%20Namespace%20Details">Local Namespace Details</a>.
+<code>sys/socket.h</code> (POSIX):  <a href="#Local Namespace Details">Local Namespace Details</a>.
 
 <br><dt><code>int PF_UNIX</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Local%20Namespace%20Details">Local Namespace Details</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Local Namespace Details">Local Namespace Details</a>.
 
 <br><dt><code>pid_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#Process%20Identification">Process Identification</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#Process Identification">Process Identification</a>.
 
 <br><dt><code>int pipe (int <var>filedes</var><tt>[2]</tt>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Creating%20a%20Pipe">Creating a Pipe</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Creating a Pipe">Creating a Pipe</a>.
 
 <br><dt><code>int PIPE_BUF</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#Limits%20for%20Files">Limits for Files</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#Limits for Files">Limits for Files</a>.
 
 <br><dt><code>FILE * popen (const char *<var>command</var>, const char *<var>mode</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX.2, SVID, BSD):  <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>.
+<code>stdio.h</code> (POSIX.2, SVID, BSD):  <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>.
 
 <br><dt><code>_POSIX2_BC_BASE_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>_POSIX2_BC_DIM_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>_POSIX2_BC_SCALE_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>_POSIX2_BC_STRING_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>int _POSIX2_C_DEV</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#System%20Options">System Options</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#System Options">System Options</a>.
 
 <br><dt><code>_POSIX2_COLL_WEIGHTS_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>long int _POSIX2_C_VERSION</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Version%20Supported">Version Supported</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Version Supported">Version Supported</a>.
 
 <br><dt><code>_POSIX2_EQUIV_CLASS_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>_POSIX2_EXPR_NEST_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>int _POSIX2_FORT_DEV</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#System%20Options">System Options</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#System Options">System Options</a>.
 
 <br><dt><code>int _POSIX2_FORT_RUN</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#System%20Options">System Options</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#System Options">System Options</a>.
 
 <br><dt><code>_POSIX2_LINE_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#Utility%20Minimums">Utility Minimums</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#Utility Minimums">Utility Minimums</a>.
 
 <br><dt><code>int _POSIX2_LOCALEDEF</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#System%20Options">System Options</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#System Options">System Options</a>.
 
 <br><dt><code>_POSIX2_RE_DUP_MAX</code>
 <dd>
 <code>limits.h</code> (POSIX.2):  <a href="#Minimums">Minimums</a>.
 
 <br><dt><code>int _POSIX2_SW_DEV</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#System%20Options">System Options</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#System Options">System Options</a>.
 
 <br><dt><code>_POSIX_AIO_LISTIO_MAX</code>
 <dd>
 <code>limits.h</code> (POSIX.1):  <a href="#Minimums">Minimums</a>.
@@ -82312,81 +80703,81 @@
 <code>limits.h</code> (POSIX.1):  <a href="#Minimums">Minimums</a>.
 
 <br><dt><code>int _POSIX_CHOWN_RESTRICTED</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Options%20for%20Files">Options for Files</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Options for Files">Options for Files</a>.
 
 <br><dt><code>_POSIX_C_SOURCE</code>
 <dd>
-(POSIX.2):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(POSIX.2):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>int _POSIX_JOB_CONTROL</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#System%20Options">System Options</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#System Options">System Options</a>.
 
 <br><dt><code>_POSIX_LINK_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>_POSIX_MAX_CANON</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>_POSIX_MAX_INPUT</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>int posix_memalign (void **<var>memptr</var>, size_t <var>alignment</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdlib.h</code> (POSIX):  <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>.
+<code>stdlib.h</code> (POSIX):  <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>.
 
 <br><dt><code>_POSIX_NAME_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>_POSIX_NGROUPS_MAX</code>
 <dd>
 <code>limits.h</code> (POSIX.1):  <a href="#Minimums">Minimums</a>.
 
 <br><dt><code>int _POSIX_NO_TRUNC</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Options%20for%20Files">Options for Files</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Options for Files">Options for Files</a>.
 
 <br><dt><code>_POSIX_OPEN_MAX</code>
 <dd>
 <code>limits.h</code> (POSIX.1):  <a href="#Minimums">Minimums</a>.
 
 <br><dt><code>_POSIX_PATH_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>_POSIX_PIPE_BUF</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>POSIX_REC_INCR_XFER_SIZE</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>POSIX_REC_MAX_XFER_SIZE</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>POSIX_REC_MIN_XFER_SIZE</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>POSIX_REC_XFER_ALIGN</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>int _POSIX_SAVED_IDS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#System%20Options">System Options</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#System Options">System Options</a>.
 
 <br><dt><code>_POSIX_SOURCE</code>
 <dd>
-(POSIX.1):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(POSIX.1):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_POSIX_SSIZE_MAX</code>
 <dd>
 <code>limits.h</code> (POSIX.1):  <a href="#Minimums">Minimums</a>.
@@ -82400,105 +80791,105 @@
 <code>limits.h</code> (POSIX.1):  <a href="#Minimums">Minimums</a>.
 
 <br><dt><code>unsigned char _POSIX_VDISABLE</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Options%20for%20Files">Options for Files</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Options for Files">Options for Files</a>.
 
 <br><dt><code>long int _POSIX_VERSION</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Version%20Supported">Version Supported</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Version Supported">Version Supported</a>.
 
 <br><dt><code>double pow (double <var>base</var>, double <var>power</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>double pow10 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float pow10f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double pow10l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (GNU):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float powf (float <var>base</var>, float <var>power</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double powl (long double <var>base</var>, long double <var>power</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>ssize_t pread (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>, off_t <var>offset</var>)</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+<code>unistd.h</code> (Unix98):  <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <br><dt><code>ssize_t pread64 (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>, off64_t <var>offset</var>)</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+<code>unistd.h</code> (Unix98):  <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <br><dt><code>int printf (const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>.
+<code>stdio.h</code> (ISO):  <a href="#Formatted Output Functions">Formatted Output Functions</a>.
 
 <br><dt><code>printf_arginfo_function</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>.
+<code>printf.h</code> (GNU):  <a href="#Defining the Output Handler">Defining the Output Handler</a>.
 
 <br><dt><code>printf_function</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>.
+<code>printf.h</code> (GNU):  <a href="#Defining the Output Handler">Defining the Output Handler</a>.
 
 <br><dt><code>int printf_size (FILE *<var>fp</var>, const struct printf_info *<var>info</var>, const void *const *<var>args</var>)</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>.
+<code>printf.h</code> (GNU):  <a href="#Predefined Printf Handlers">Predefined Printf Handlers</a>.
 
 <br><dt><code>int printf_size_info (const struct printf_info *<var>info</var>, size_t <var>n</var>, int *<var>argtypes</var>)</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>.
+<code>printf.h</code> (GNU):  <a href="#Predefined Printf Handlers">Predefined Printf Handlers</a>.
 
 <br><dt><code>PRIO_MAX</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>PRIO_MIN</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>PRIO_PGRP</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>PRIO_PROCESS</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>PRIO_USER</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>char * program_invocation_name</code>
 <dd>
-<code>errno.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>errno.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>char * program_invocation_short_name</code>
 <dd>
-<code>errno.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>errno.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>void psignal (int <var>signum</var>, const char *<var>message</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Signal%20Messages">Signal Messages</a>.
+<code>signal.h</code> (BSD):  <a href="#Signal Messages">Signal Messages</a>.
 
 <br><dt><code>char * P_tmpdir</code>
 <dd>
-<code>stdio.h</code> (SVID):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (SVID):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>ptrdiff_t</code>
 <dd>
-<code>stddef.h</code> (ISO):  <a href="#Important%20Data%20Types">Important Data Types</a>.
+<code>stddef.h</code> (ISO):  <a href="#Important Data Types">Important Data Types</a>.
 
 <br><dt><code>char * ptsname (int <var>filedes</var>)</code>
 <dd>
 <code>stdlib.h</code> (SVID, XPG4.2):  <a href="#Allocation">Allocation</a>.
@@ -82508,1137 +80899,1137 @@
 <code>stdlib.h</code> (GNU):  <a href="#Allocation">Allocation</a>.
 
 <br><dt><code>int putc (int <var>c</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int putchar (int <var>c</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int putchar_unlocked (int <var>c</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int putc_unlocked (int <var>c</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (POSIX):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (POSIX):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>int putenv (char *<var>string</var>)</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#Environment%20Access">Environment Access</a>.
+<code>stdlib.h</code> (SVID):  <a href="#Environment Access">Environment Access</a>.
 
 <br><dt><code>int putpwent (const struct passwd *<var>p</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>pwd.h</code> (SVID):  <a href="#Writing%20a%20User%20Entry">Writing a User Entry</a>.
+<code>pwd.h</code> (SVID):  <a href="#Writing a User Entry">Writing a User Entry</a>.
 
 <br><dt><code>int puts (const char *<var>s</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>struct utmp * pututline (const struct utmp *<var>utmp</var>)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>struct utmpx * pututxline (const struct utmpx *<var>utmp</var>)</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int putw (int <var>w</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (SVID):  <a href="#Simple%20Output">Simple Output</a>.
+<code>stdio.h</code> (SVID):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>wint_t putwc (wchar_t <var>wc</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>wint_t putwchar (wchar_t <var>wc</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (ISO):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>wint_t putwchar_unlocked (wchar_t <var>wc</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (GNU):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>wint_t putwc_unlocked (wchar_t <var>wc</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Simple%20Output">Simple Output</a>.
+<code>wchar.h</code> (GNU):  <a href="#Simple Output">Simple Output</a>.
 
 <br><dt><code>ssize_t pwrite (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>, off_t <var>offset</var>)</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+<code>unistd.h</code> (Unix98):  <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <br><dt><code>ssize_t pwrite64 (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>, off64_t <var>offset</var>)</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+<code>unistd.h</code> (Unix98):  <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <br><dt><code>char * qecvt (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (GNU):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>char * qecvt_r (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (GNU):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>char * qfcvt (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (GNU):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>char * qfcvt_r (long double <var>value</var>, int <var>ndigit</var>, int *<var>decpt</var>, int *<var>neg</var>, char *<var>buf</var>, size_t <var>len</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (GNU):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>char * qgcvt (long double <var>value</var>, int <var>ndigit</var>, char *<var>buf</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>.
+<code>stdlib.h</code> (GNU):  <a href="#System V Number Conversion">System V Number Conversion</a>.
 
 <br><dt><code>void qsort (void *<var>array</var>, size_t <var>count</var>, size_t <var>size</var>, comparison_fn_t <var>compare</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Array%20Sort%20Function">Array Sort Function</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Array Sort Function">Array Sort Function</a>.
 
 <br><dt><code>int raise (int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Signaling%20Yourself">Signaling Yourself</a>.
+<code>signal.h</code> (ISO):  <a href="#Signaling Yourself">Signaling Yourself</a>.
 
 <br><dt><code>int rand (void)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#ISO%20Random">ISO Random</a>.
+<code>stdlib.h</code> (ISO):  <a href="#ISO Random">ISO Random</a>.
 
 <br><dt><code>int RAND_MAX</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#ISO%20Random">ISO Random</a>.
+<code>stdlib.h</code> (ISO):  <a href="#ISO Random">ISO Random</a>.
 
 <br><dt><code>long int random (void)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (BSD):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>int random_r (struct random_data *restrict <var>buf</var>, int32_t *restrict <var>result</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>int rand_r (unsigned int *<var>seed</var>)</code>
 <dd>
-<code>stdlib.h</code> (POSIX.1):  <a href="#ISO%20Random">ISO Random</a>.
+<code>stdlib.h</code> (POSIX.1):  <a href="#ISO Random">ISO Random</a>.
 
 <br><dt><code>void * rawmemchr (const void *<var>block</var>, int <var>c</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (GNU):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>ssize_t read (int <var>filedes</var>, void *<var>buffer</var>, size_t <var>size</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <br><dt><code>struct dirent * readdir (DIR *<var>dirstream</var>)</code>
 <dd>
-<code>dirent.h</code> (POSIX.1):  <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>.
+<code>dirent.h</code> (POSIX.1):  <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>.
 
 <br><dt><code>struct dirent64 * readdir64 (DIR *<var>dirstream</var>)</code>
 <dd>
-<code>dirent.h</code> (LFS):  <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>.
+<code>dirent.h</code> (LFS):  <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>.
 
 <br><dt><code>int readdir64_r (DIR *<var>dirstream</var>, struct dirent64 *<var>entry</var>, struct dirent64 **<var>result</var>)</code>
 <dd>
-<code>dirent.h</code> (LFS):  <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>.
+<code>dirent.h</code> (LFS):  <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>.
 
 <br><dt><code>int readdir_r (DIR *<var>dirstream</var>, struct dirent *<var>entry</var>, struct dirent **<var>result</var>)</code>
 <dd>
-<code>dirent.h</code> (GNU):  <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>.
+<code>dirent.h</code> (GNU):  <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>.
 
 <br><dt><code>int readlink (const char *<var>filename</var>, char *<var>buffer</var>, size_t <var>size</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Symbolic%20Links">Symbolic Links</a>.
+<code>unistd.h</code> (BSD):  <a href="#Symbolic Links">Symbolic Links</a>.
 
 <br><dt><code>ssize_t readv (int <var>filedes</var>, const struct iovec *<var>vector</var>, int <var>count</var>)</code>
 <dd>
 <code>sys/uio.h</code> (BSD):  <a href="#Scatter-Gather">Scatter-Gather</a>.
 
 <br><dt><code>void * realloc (void *<var>ptr</var>, size_t <var>newsize</var>)</code>
 <dd>
-<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Changing%20Block%20Size">Changing Block Size</a>.
+<code>malloc.h</code>, <code>stdlib.h</code> (ISO):  <a href="#Changing Block Size">Changing Block Size</a>.
 
 <br><dt><code>__realloc_hook</code>
 <dd>
-<code>malloc.h</code> (GNU):  <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>.
+<code>malloc.h</code> (GNU):  <a href="#Hooks for Malloc">Hooks for Malloc</a>.
 
 <br><dt><code>char * realpath (const char *restrict <var>name</var>, char *restrict <var>resolved</var>)</code>
 <dd>
-<code>stdlib.h</code> (XPG):  <a href="#Symbolic%20Links">Symbolic Links</a>.
+<code>stdlib.h</code> (XPG):  <a href="#Symbolic Links">Symbolic Links</a>.
 
 <br><dt><code>int recv (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Receiving%20Data">Receiving Data</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Receiving Data">Receiving Data</a>.
 
 <br><dt><code>int recvfrom (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>, struct sockaddr *<var>addr</var>, socklen_t *<var>length-ptr</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Receiving%20Datagrams">Receiving Datagrams</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Receiving Datagrams">Receiving Datagrams</a>.
 
 <br><dt><code>int recvmsg (int <var>socket</var>, struct msghdr *<var>message</var>, int <var>flags</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Receiving%20Datagrams">Receiving Datagrams</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Receiving Datagrams">Receiving Datagrams</a>.
 
 <br><dt><code>int RE_DUP_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.2):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.2):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>_REENTRANT</code>
 <dd>
-(GNU):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(GNU):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>REG_BADBR</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_BADPAT</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_BADRPT</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>int regcomp (regex_t *<var>compiled</var>, const char *<var>pattern</var>, int <var>cflags</var>)</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_EBRACE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_EBRACK</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_ECOLLATE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_ECTYPE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_EESCAPE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_EPAREN</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_ERANGE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>size_t regerror (int <var>errcode</var>, regex_t *<var>compiled</var>, char *<var>buffer</var>, size_t <var>length</var>)</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Regexp%20Cleanup">Regexp Cleanup</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Regexp Cleanup">Regexp Cleanup</a>.
 
 <br><dt><code>REG_ESPACE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>.
 
 <br><dt><code>REG_ESPACE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_ESUBREG</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>int regexec (regex_t *<var>compiled</var>, char *<var>string</var>, size_t <var>nmatch</var>, regmatch_t <var>matchptr</var> <tt>[]</tt>, int <var>eflags</var>)</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>.
 
 <br><dt><code>regex_t</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>.
 
 <br><dt><code>REG_EXTENDED</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>.
 
 <br><dt><code>void regfree (regex_t *<var>compiled</var>)</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Regexp%20Cleanup">Regexp Cleanup</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Regexp Cleanup">Regexp Cleanup</a>.
 
 <br><dt><code>REG_ICASE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>.
 
 <br><dt><code>int register_printf_function (int <var>spec</var>, printf_function <var>handler-function</var>, printf_arginfo_function <var>arginfo-function</var>)</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Registering%20New%20Conversions">Registering New Conversions</a>.
+<code>printf.h</code> (GNU):  <a href="#Registering New Conversions">Registering New Conversions</a>.
 
 <br><dt><code>regmatch_t</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Regexp%20Subexpressions">Regexp Subexpressions</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Regexp Subexpressions">Regexp Subexpressions</a>.
 
 <br><dt><code>REG_NEWLINE</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>.
 
 <br><dt><code>REG_NOMATCH</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>.
 
 <br><dt><code>REG_NOSUB</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Flags for POSIX Regexps">Flags for POSIX Regexps</a>.
 
 <br><dt><code>REG_NOTBOL</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>.
 
 <br><dt><code>REG_NOTEOL</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>.
 
 <br><dt><code>regoff_t</code>
 <dd>
-<code>regex.h</code> (POSIX.2):  <a href="#Regexp%20Subexpressions">Regexp Subexpressions</a>.
+<code>regex.h</code> (POSIX.2):  <a href="#Regexp Subexpressions">Regexp Subexpressions</a>.
 
 <br><dt><code>double remainder (double <var>numerator</var>, double <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>float remainderf (float <var>numerator</var>, float <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>long double remainderl (long double <var>numerator</var>, long double <var>denominator</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Remainder%20Functions">Remainder Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Remainder Functions">Remainder Functions</a>.
 
 <br><dt><code>int remove (const char *<var>filename</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Deleting%20Files">Deleting Files</a>.
+<code>stdio.h</code> (ISO):  <a href="#Deleting Files">Deleting Files</a>.
 
 <br><dt><code>int rename (const char *<var>oldname</var>, const char *<var>newname</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Renaming%20Files">Renaming Files</a>.
+<code>stdio.h</code> (ISO):  <a href="#Renaming Files">Renaming Files</a>.
 
 <br><dt><code>void rewind (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>void rewinddir (DIR *<var>dirstream</var>)</code>
 <dd>
-<code>dirent.h</code> (POSIX.1):  <a href="#Random%20Access%20Directory">Random Access Directory</a>.
+<code>dirent.h</code> (POSIX.1):  <a href="#Random Access Directory">Random Access Directory</a>.
 
 <br><dt><code>char * rindex (const char *<var>string</var>, int <var>c</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (BSD):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>double rint (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>float rintf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long double rintl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>int RLIM_INFINITY</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_AS</code>
 <dd>
-<code>sys/resource.h</code> (Unix98):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (Unix98):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_CORE</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_CPU</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_DATA</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_FSIZE</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_MEMLOCK</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_NOFILE</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_NPROC</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_RSS</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIMIT_STACK</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>RLIM_NLIMITS</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>int rmdir (const char *<var>filename</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Deleting%20Files">Deleting Files</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Deleting Files">Deleting Files</a>.
 
 <br><dt><code>int R_OK</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Testing%20File%20Access">Testing File Access</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Testing File Access">Testing File Access</a>.
 
 <br><dt><code>double round (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>float roundf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long double roundl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>int rpmatch (const char *<var>response</var>)</code>
 <dd>
-<code>stdlib.h</code> (stdlib.h):  <a href="#Yes-or-No%20Questions">Yes-or-No Questions</a>.
+<code>stdlib.h</code> (stdlib.h):  <a href="#Yes-or-No Questions">Yes-or-No Questions</a>.
 
 <br><dt><code>RUN_LVL</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>RUN_LVL</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>RUSAGE_CHILDREN</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Resource%20Usage">Resource Usage</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Resource Usage">Resource Usage</a>.
 
 <br><dt><code>RUSAGE_SELF</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Resource%20Usage">Resource Usage</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Resource Usage">Resource Usage</a>.
 
 <br><dt><code>int SA_NOCLDSTOP</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Flags for Sigaction">Flags for Sigaction</a>.
 
 <br><dt><code>int SA_ONSTACK</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>.
+<code>signal.h</code> (BSD):  <a href="#Flags for Sigaction">Flags for Sigaction</a>.
 
 <br><dt><code>int SA_RESTART</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>.
+<code>signal.h</code> (BSD):  <a href="#Flags for Sigaction">Flags for Sigaction</a>.
 
 <br><dt><code>int sbrk (ptrdiff_t <var>delta</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>.
+<code>unistd.h</code> (BSD):  <a href="#Resizing the Data Segment">Resizing the Data Segment</a>.
 
 <br><dt><code>_SC_2_C_DEV</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_2_FORT_DEV</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_2_FORT_RUN</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_2_LOCALEDEF</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_2_SW_DEV</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_2_VERSION</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_AIO_LISTIO_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_AIO_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_AIO_PRIO_DELTA_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>double scalb (double <var>value</var>, int <var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>float scalbf (float <var>value</var>, int <var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long double scalbl (long double <var>value</var>, int <var>exponent</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int scalbln (double <var>x</var>, long int n)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int scalblnf (float <var>x</var>, long int n)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int scalblnl (long double <var>x</var>, long int n)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int scalbn (double <var>x</var>, int n)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int scalbnf (float <var>x</var>, int n)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int scalbnl (long double <var>x</var>, int n)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>int scandir (const char *<var>dir</var>, struct dirent ***<var>namelist</var>, int (*<var>selector</var>) (const struct dirent *), int (*<var>cmp</var>) (const void *, const void *))</code>
 <dd>
-<code>dirent.h</code> (BSD/SVID):  <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>.
+<code>dirent.h</code> (BSD/SVID):  <a href="#Scanning Directory Content">Scanning Directory Content</a>.
 
 <br><dt><code>int scandir64 (const char *<var>dir</var>, struct dirent64 ***<var>namelist</var>, int (*<var>selector</var>) (const struct dirent64 *), int (*<var>cmp</var>) (const void *, const void *))</code>
 <dd>
-<code>dirent.h</code> (GNU):  <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>.
+<code>dirent.h</code> (GNU):  <a href="#Scanning Directory Content">Scanning Directory Content</a>.
 
 <br><dt><code>int scanf (const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>.
+<code>stdio.h</code> (ISO):  <a href="#Formatted Input Functions">Formatted Input Functions</a>.
 
 <br><dt><code>_SC_ARG_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_ASYNCHRONOUS_IO</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_ATEXIT_MAX</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (GNU):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_AVPHYS_PAGES</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (GNU):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_BC_BASE_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_BC_DIM_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_BC_SCALE_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_BC_STRING_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_CHAR_BIT</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_CHARCLASS_NAME_MAX</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (GNU):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_CHAR_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_CHAR_MIN</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_CHILD_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_CLK_TCK</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_COLL_WEIGHTS_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_DELAYTIMER_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_EQUIV_CLASS_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_EXPR_NEST_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_FSYNC</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_GETGR_R_SIZE_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_GETPW_R_SIZE_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>SCHAR_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>SCHAR_MIN</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>int sched_getparam (pid_t <var>pid</var>, const struct sched_param *<var>param</var>)</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>int sched_get_priority_max (int *<var>policy</var>);</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>int sched_get_priority_min (int *<var>policy</var>);</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>int sched_getscheduler (pid_t <var>pid</var>)</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>int sched_rr_get_interval (pid_t <var>pid</var>, struct timespec *<var>interval</var>)</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>int sched_setparam (pid_t <var>pid</var>, const struct sched_param *<var>param</var>)</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>int sched_setscheduler (pid_t <var>pid</var>, int <var>policy</var>, const struct sched_param *<var>param</var>)</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>int sched_yield (void)</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>_SC_INT_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_INT_MIN</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_JOB_CONTROL</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_LINE_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_LOGIN_NAME_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_LONG_BIT</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MAPPED_FILES</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MB_LEN_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MEMLOCK</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MEMLOCK_RANGE</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MEMORY_PROTECTION</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MESSAGE_PASSING</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MQ_OPEN_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_MQ_PRIO_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NGROUPS_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NL_ARGMAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NL_LANGMAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NL_MSGMAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NL_NMAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NL_SETMAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NL_TEXTMAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NPROCESSORS_CONF</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (GNU):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NPROCESSORS_ONLN</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (GNU):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_NZERO</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_OPEN_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PAGESIZE</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (GNU):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PHYS_PAGES</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (GNU):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_INTERNET</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_INTERNET_DGRAM</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_INTERNET_STREAM</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_OSI</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_OSI_CLTS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_OSI_COTS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_OSI_M</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_SOCKET</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PII_XTI</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PRIORITIZED_IO</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_PRIORITY_SCHEDULING</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_REALTIME_SIGNALS</code>
 <dd>
-<code>unistdh.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistdh.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_RTSIG_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SAVED_IDS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SCHAR_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SCHAR_MIN</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SELECT</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SEMAPHORES</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SEM_NSEMS_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SEM_VALUE_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SHARED_MEMORY_OBJECTS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SHRT_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SHRT_MIN</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SIGQUEUE_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>SC_SSIZE_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_STREAM_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_SYNCHRONIZED_IO</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_ATTR_STACKADDR</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_ATTR_STACKSIZE</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_DESTRUCTOR_ITERATIONS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_KEYS_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_PRIO_INHERIT</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_PRIO_PROTECT</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_PRIORITY_SCHEDULING</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_PROCESS_SHARED</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREADS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_SAFE_FUNCTIONS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_STACK_MIN</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_THREAD_THREADS_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_TIMER_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_TIMERS</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_T_IOV_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_TTY_NAME_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_TZNAME_MAX</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_UCHAR_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_UINT_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_UIO_MAXIOV</code>
 <dd>
-<code>unistd.h</code> (POSIX.1g):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1g):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_ULONG_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_USHRT_MAX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_VERSION</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_VERSION</code>
 <dd>
-<code>unistd.h</code> (POSIX.2):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (POSIX.2):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_WORD_BIT</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_CRYPT</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_ENH_I18N</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_LEGACY</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_REALTIME</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_REALTIME_THREADS</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_SHM</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_UNIX</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_VERSION</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_XCU_VERSION</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_XPG2</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_XPG3</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>_SC_XOPEN_XPG4</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Constants for Sysconf">Constants for Sysconf</a>.
 
 <br><dt><code>unsigned short int * seed48 (unsigned short int <var>seed16v</var>[3])</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int seed48_r (unsigned short int <var>seed16v</var>[3], struct drand48_data *<var>buffer</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int SEEK_CUR</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>void seekdir (DIR *<var>dirstream</var>, off_t <var>pos</var>)</code>
 <dd>
-<code>dirent.h</code> (BSD):  <a href="#Random%20Access%20Directory">Random Access Directory</a>.
+<code>dirent.h</code> (BSD):  <a href="#Random Access Directory">Random Access Directory</a>.
 
 <br><dt><code>int SEEK_END</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int SEEK_SET</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#File%20Positioning">File Positioning</a>.
+<code>stdio.h</code> (ISO):  <a href="#File Positioning">File Positioning</a>.
 
 <br><dt><code>int select (int <var>nfds</var>, fd_set *<var>read-fds</var>, fd_set *<var>write-fds</var>, fd_set *<var>except-fds</var>, struct timeval *<var>timeout</var>)</code>
 <dd>
-<code>sys/types.h</code> (BSD):  <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>.
+<code>sys/types.h</code> (BSD):  <a href="#Waiting for I%2fO">Waiting for I/O</a>.
 
 <br><dt><code>int send (int <var>socket</var>, void *<var>buffer</var>, size_t <var>size</var>, int <var>flags</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Sending%20Data">Sending Data</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Sending Data">Sending Data</a>.
 
 <br><dt><code>int sendmsg (int <var>socket</var>, const struct msghdr *<var>message</var>, int <var>flags</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Receiving%20Datagrams">Receiving Datagrams</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Receiving Datagrams">Receiving Datagrams</a>.
 
 <br><dt><code>int sendto (int <var>socket</var>, void *<var>buffer</var>. size_t <var>size</var>, int <var>flags</var>, struct sockaddr *<var>addr</var>, socklen_t <var>length</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Sending%20Datagrams">Sending Datagrams</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Sending Datagrams">Sending Datagrams</a>.
 
 <br><dt><code>void setbuf (FILE *<var>stream</var>, char *<var>buf</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (ISO):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>void setbuffer (FILE *<var>stream</var>, char *<var>buf</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdio.h</code> (BSD):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (BSD):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>int setcontext (const ucontext_t *<var>ucp</var>)</code>
 <dd>
-<code>ucontext.h</code> (SVID):  <a href="#System%20V%20contexts">System V contexts</a>.
+<code>ucontext.h</code> (SVID):  <a href="#System V contexts">System V contexts</a>.
 
 <br><dt><code>int setdomainname (const char *<var>name</var>, size_t <var>length</var>)</code>
 <dd>
-<code>unistd.h</code> (???):  <a href="#Host%20Identification">Host Identification</a>.
+<code>unistd.h</code> (???):  <a href="#Host Identification">Host Identification</a>.
 
 <br><dt><code>int setegid (gid_t <var>newgid</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Setting%20Groups">Setting Groups</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Setting Groups">Setting Groups</a>.
 
 <br><dt><code>int setenv (const char *<var>name</var>, const char *<var>value</var>, int <var>replace</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#Environment%20Access">Environment Access</a>.
+<code>stdlib.h</code> (BSD):  <a href="#Environment Access">Environment Access</a>.
 
 <br><dt><code>int seteuid (uid_t <var>neweuid</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Setting%20User%20ID">Setting User ID</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Setting User ID">Setting User ID</a>.
 
 <br><dt><code>int setfsent (void)</code>
 <dd>
 <code>fstab.h</code> (BSD):  <a href="#fstab">fstab</a>.
 
 <br><dt><code>int setgid (gid_t <var>newgid</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Setting%20Groups">Setting Groups</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Setting Groups">Setting Groups</a>.
 
 <br><dt><code>void setgrent (void)</code>
 <dd>
-<code>grp.h</code> (SVID, BSD):  <a href="#Scanning%20All%20Groups">Scanning All Groups</a>.
+<code>grp.h</code> (SVID, BSD):  <a href="#Scanning All Groups">Scanning All Groups</a>.
 
 <br><dt><code>int setgroups (size_t <var>count</var>, gid_t *<var>groups</var>)</code>
 <dd>
-<code>grp.h</code> (BSD):  <a href="#Setting%20Groups">Setting Groups</a>.
+<code>grp.h</code> (BSD):  <a href="#Setting Groups">Setting Groups</a>.
 
 <br><dt><code>void sethostent (int <var>stayopen</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>int sethostid (long int <var>id</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Host%20Identification">Host Identification</a>.
+<code>unistd.h</code> (BSD):  <a href="#Host Identification">Host Identification</a>.
 
 <br><dt><code>int sethostname (const char *<var>name</var>, size_t <var>length</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Host%20Identification">Host Identification</a>.
+<code>unistd.h</code> (BSD):  <a href="#Host Identification">Host Identification</a>.
 
 <br><dt><code>int setitimer (int <var>which</var>, struct itimerval *<var>new</var>, struct itimerval *<var>old</var>)</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<code>sys/time.h</code> (BSD):  <a href="#Setting an Alarm">Setting an Alarm</a>.
 
 <br><dt><code>int setjmp (jmp_buf <var>state</var>)</code>
 <dd>
-<code>setjmp.h</code> (ISO):  <a href="#Non-Local%20Details">Non-Local Details</a>.
+<code>setjmp.h</code> (ISO):  <a href="#Non-Local Details">Non-Local Details</a>.
 
 <br><dt><code>void setkey (const char *<var>key</var>)</code>
 <dd>
-<code>crypt.h</code> (BSD, SVID):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>crypt.h</code> (BSD, SVID):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>void setkey_r (const char *<var>key</var>, struct crypt_data * <var>data</var>)</code>
 <dd>
-<code>crypt.h</code> (GNU):  <a href="#DES%20Encryption">DES Encryption</a>.
+<code>crypt.h</code> (GNU):  <a href="#DES Encryption">DES Encryption</a>.
 
 <br><dt><code>void setlinebuf (FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (BSD):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (BSD):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>char * setlocale (int <var>category</var>, const char *<var>locale</var>)</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#Setting%20the%20Locale">Setting the Locale</a>.
+<code>locale.h</code> (ISO):  <a href="#Setting the Locale">Setting the Locale</a>.
 
 <br><dt><code>int setlogmask (int <var>mask</var>)</code>
 <dd>
 <code>syslog.h</code> (BSD):  <a href="#setlogmask">setlogmask</a>.
@@ -83648,1505 +82039,1505 @@
 <code>mntent.h</code> (BSD):  <a href="#mtab">mtab</a>.
 
 <br><dt><code>void setnetent (int <var>stayopen</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Networks%20Database">Networks Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Networks Database">Networks Database</a>.
 
 <br><dt><code>int setnetgrent (const char *<var>netgroup</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Lookup%20Netgroup">Lookup Netgroup</a>.
+<code>netdb.h</code> (BSD):  <a href="#Lookup Netgroup">Lookup Netgroup</a>.
 
 <br><dt><code>int setpgid (pid_t <var>pid</var>, pid_t <var>pgid</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Process Group Functions">Process Group Functions</a>.
 
 <br><dt><code>int setpgrp (pid_t <var>pid</var>, pid_t <var>pgid</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+<code>unistd.h</code> (BSD):  <a href="#Process Group Functions">Process Group Functions</a>.
 
 <br><dt><code>int setpriority (int <var>class</var>, int <var>id</var>, int <var>niceval</var>)</code>
 <dd>
-<code>sys/resource.h</code> (BSD,POSIX):  <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>.
+<code>sys/resource.h</code> (BSD,POSIX):  <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>.
 
 <br><dt><code>void setprotoent (int <var>stayopen</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Protocols%20Database">Protocols Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Protocols Database">Protocols Database</a>.
 
 <br><dt><code>void setpwent (void)</code>
 <dd>
-<code>pwd.h</code> (SVID, BSD):  <a href="#Scanning%20All%20Users">Scanning All Users</a>.
+<code>pwd.h</code> (SVID, BSD):  <a href="#Scanning All Users">Scanning All Users</a>.
 
 <br><dt><code>int setregid (gid_t <var>rgid</var>, gid_t <var>egid</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Setting%20Groups">Setting Groups</a>.
+<code>unistd.h</code> (BSD):  <a href="#Setting Groups">Setting Groups</a>.
 
 <br><dt><code>int setreuid (uid_t <var>ruid</var>, uid_t <var>euid</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Setting%20User%20ID">Setting User ID</a>.
+<code>unistd.h</code> (BSD):  <a href="#Setting User ID">Setting User ID</a>.
 
 <br><dt><code>int setrlimit (int <var>resource</var>, const struct rlimit *<var>rlp</var>)</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>int setrlimit64 (int <var>resource</var>, const struct rlimit64 *<var>rlp</var>)</code>
 <dd>
-<code>sys/resource.h</code> (Unix98):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (Unix98):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>void setservent (int <var>stayopen</var>)</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Services%20Database">Services Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Services Database">Services Database</a>.
 
 <br><dt><code>pid_t setsid (void)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Process%20Group%20Functions">Process Group Functions</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Process Group Functions">Process Group Functions</a>.
 
 <br><dt><code>int setsockopt (int <var>socket</var>, int <var>level</var>, int <var>optname</var>, void *<var>optval</var>, socklen_t <var>optlen</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket%20Option%20Functions">Socket Option Functions</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket Option Functions">Socket Option Functions</a>.
 
 <br><dt><code>void * setstate (void *<var>state</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (BSD):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>int setstate_r (char *restrict <var>statebuf</var>, struct random_data *restrict <var>buf</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>int settimeofday (const struct timeval *<var>tp</var>, const struct timezone *<var>tzp</var>)</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.
+<code>sys/time.h</code> (BSD):  <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.
 
 <br><dt><code>int setuid (uid_t <var>newuid</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Setting%20User%20ID">Setting User ID</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Setting User ID">Setting User ID</a>.
 
 <br><dt><code>void setutent (void)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>void setutxent (void)</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>int setvbuf (FILE *<var>stream</var>, char *<var>buf</var>, int <var>mode</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Controlling%20Buffering">Controlling Buffering</a>.
+<code>stdio.h</code> (ISO):  <a href="#Controlling Buffering">Controlling Buffering</a>.
 
 <br><dt><code>SHRT_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>SHRT_MIN</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>int shutdown (int <var>socket</var>, int <var>how</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Closing%20a%20Socket">Closing a Socket</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Closing a Socket">Closing a Socket</a>.
 
 <br><dt><code>S_IEXEC</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IFBLK</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_IFCHR</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_IFDIR</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_IFIFO</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_IFLNK</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_IFMT</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_IFREG</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_IFSOCK</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int SIGABRT</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (ISO):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int sigaction (int <var>signum</var>, const struct sigaction *restrict <var>action</var>, struct sigaction *restrict <var>old-action</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Advanced Signal Handling">Advanced Signal Handling</a>.
 
 <br><dt><code>int sigaddset (sigset_t *<var>set</var>, int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Signal%20Sets">Signal Sets</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Signal Sets">Signal Sets</a>.
 
 <br><dt><code>int SIGALRM</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Alarm%20Signals">Alarm Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Alarm Signals">Alarm Signals</a>.
 
 <br><dt><code>int sigaltstack (const stack_t *restrict <var>stack</var>, stack_t *restrict <var>oldstack</var>)</code>
 <dd>
-<code>signal.h</code> (XPG):  <a href="#Signal%20Stack">Signal Stack</a>.
+<code>signal.h</code> (XPG):  <a href="#Signal Stack">Signal Stack</a>.
 
 <br><dt><code>sig_atomic_t</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Atomic%20Types">Atomic Types</a>.
+<code>signal.h</code> (ISO):  <a href="#Atomic Types">Atomic Types</a>.
 
 <br><dt><code>SIG_BLOCK</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Process%20Signal%20Mask">Process Signal Mask</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Process Signal Mask">Process Signal Mask</a>.
 
 <br><dt><code>int sigblock (int <var>mask</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Blocking%20in%20BSD">Blocking in BSD</a>.
+<code>signal.h</code> (BSD):  <a href="#Blocking in BSD">Blocking in BSD</a>.
 
 <br><dt><code>int SIGBUS</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int SIGCHLD</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Job%20Control%20Signals">Job Control Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Job Control Signals">Job Control Signals</a>.
 
 <br><dt><code>int SIGCLD</code>
 <dd>
-<code>signal.h</code> (SVID):  <a href="#Job%20Control%20Signals">Job Control Signals</a>.
+<code>signal.h</code> (SVID):  <a href="#Job Control Signals">Job Control Signals</a>.
 
 <br><dt><code>int SIGCONT</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Job%20Control%20Signals">Job Control Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Job Control Signals">Job Control Signals</a>.
 
 <br><dt><code>int sigdelset (sigset_t *<var>set</var>, int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Signal%20Sets">Signal Sets</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Signal Sets">Signal Sets</a>.
 
 <br><dt><code>int sigemptyset (sigset_t *<var>set</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Signal%20Sets">Signal Sets</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Signal Sets">Signal Sets</a>.
 
 <br><dt><code>int SIGEMT</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>sighandler_t SIG_ERR</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>.
+<code>signal.h</code> (ISO):  <a href="#Basic Signal Handling">Basic Signal Handling</a>.
 
 <br><dt><code>int sigfillset (sigset_t *<var>set</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Signal%20Sets">Signal Sets</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Signal Sets">Signal Sets</a>.
 
 <br><dt><code>int SIGFPE</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (ISO):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>sighandler_t</code>
 <dd>
-<code>signal.h</code> (GNU):  <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>.
+<code>signal.h</code> (GNU):  <a href="#Basic Signal Handling">Basic Signal Handling</a>.
 
 <br><dt><code>int SIGHUP</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Termination%20Signals">Termination Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Termination Signals">Termination Signals</a>.
 
 <br><dt><code>int SIGILL</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (ISO):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int SIGINFO</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Miscellaneous Signals">Miscellaneous Signals</a>.
 
 <br><dt><code>int SIGINT</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Termination%20Signals">Termination Signals</a>.
+<code>signal.h</code> (ISO):  <a href="#Termination Signals">Termination Signals</a>.
 
 <br><dt><code>int siginterrupt (int <var>signum</var>, int <var>failflag</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#BSD%20Handler">BSD Handler</a>.
+<code>signal.h</code> (BSD):  <a href="#BSD Handler">BSD Handler</a>.
 
 <br><dt><code>int SIGIO</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>.
 
 <br><dt><code>int SIGIOT</code>
 <dd>
-<code>signal.h</code> (Unix):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (Unix):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int sigismember (const sigset_t *<var>set</var>, int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Signal%20Sets">Signal Sets</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Signal Sets">Signal Sets</a>.
 
 <br><dt><code>sigjmp_buf</code>
 <dd>
-<code>setjmp.h</code> (POSIX.1):  <a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>.
+<code>setjmp.h</code> (POSIX.1):  <a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>.
 
 <br><dt><code>int SIGKILL</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Termination%20Signals">Termination Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Termination Signals">Termination Signals</a>.
 
 <br><dt><code>void siglongjmp (sigjmp_buf <var>state</var>, int <var>value</var>)</code>
 <dd>
-<code>setjmp.h</code> (POSIX.1):  <a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>.
+<code>setjmp.h</code> (POSIX.1):  <a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>.
 
 <br><dt><code>int SIGLOST</code>
 <dd>
-<code>signal.h</code> (GNU):  <a href="#Operation%20Error%20Signals">Operation Error Signals</a>.
+<code>signal.h</code> (GNU):  <a href="#Operation Error Signals">Operation Error Signals</a>.
 
 <br><dt><code>int sigmask (int <var>signum</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Blocking%20in%20BSD">Blocking in BSD</a>.
+<code>signal.h</code> (BSD):  <a href="#Blocking in BSD">Blocking in BSD</a>.
 
 <br><dt><code>sighandler_t signal (int <var>signum</var>, sighandler_t <var>action</var>)</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>.
+<code>signal.h</code> (ISO):  <a href="#Basic Signal Handling">Basic Signal Handling</a>.
 
 <br><dt><code>int signbit (<em>float-type</em> <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>.
+<code>math.h</code> (ISO):  <a href="#FP Bit Twiddling">FP Bit Twiddling</a>.
 
 <br><dt><code>long long int significand (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int significandf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>long long int significandl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (BSD):  <a href="#Normalization%20Functions">Normalization Functions</a>.
+<code>math.h</code> (BSD):  <a href="#Normalization Functions">Normalization Functions</a>.
 
 <br><dt><code>int sigpause (int <var>mask</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Blocking%20in%20BSD">Blocking in BSD</a>.
+<code>signal.h</code> (BSD):  <a href="#Blocking in BSD">Blocking in BSD</a>.
 
 <br><dt><code>int sigpending (sigset_t *<var>set</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Checking for Pending Signals">Checking for Pending Signals</a>.
 
 <br><dt><code>int SIGPIPE</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Operation%20Error%20Signals">Operation Error Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Operation Error Signals">Operation Error Signals</a>.
 
 <br><dt><code>int SIGPOLL</code>
 <dd>
-<code>signal.h</code> (SVID):  <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>.
+<code>signal.h</code> (SVID):  <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>.
 
 <br><dt><code>int sigprocmask (int <var>how</var>, const sigset_t *restrict <var>set</var>, sigset_t *restrict <var>oldset</var>)</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Process%20Signal%20Mask">Process Signal Mask</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Process Signal Mask">Process Signal Mask</a>.
 
 <br><dt><code>int SIGPROF</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Alarm%20Signals">Alarm Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Alarm Signals">Alarm Signals</a>.
 
 <br><dt><code>int SIGQUIT</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Termination%20Signals">Termination Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Termination Signals">Termination Signals</a>.
 
 <br><dt><code>int SIGSEGV</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (ISO):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int sigsetjmp (sigjmp_buf <var>state</var>, int <var>savesigs</var>)</code>
 <dd>
-<code>setjmp.h</code> (POSIX.1):  <a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>.
+<code>setjmp.h</code> (POSIX.1):  <a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>.
 
 <br><dt><code>SIG_SETMASK</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Process%20Signal%20Mask">Process Signal Mask</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Process Signal Mask">Process Signal Mask</a>.
 
 <br><dt><code>int sigsetmask (int <var>mask</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Blocking%20in%20BSD">Blocking in BSD</a>.
+<code>signal.h</code> (BSD):  <a href="#Blocking in BSD">Blocking in BSD</a>.
 
 <br><dt><code>sigset_t</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Signal%20Sets">Signal Sets</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Signal Sets">Signal Sets</a>.
 
 <br><dt><code>int sigstack (const struct sigstack *<var>stack</var>, struct sigstack *<var>oldstack</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Signal%20Stack">Signal Stack</a>.
+<code>signal.h</code> (BSD):  <a href="#Signal Stack">Signal Stack</a>.
 
 <br><dt><code>int SIGSTOP</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Job%20Control%20Signals">Job Control Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Job Control Signals">Job Control Signals</a>.
 
 <br><dt><code>int sigsuspend (const sigset_t *<var>set</var>)</code>
 <dd>
 <code>signal.h</code> (POSIX.1):  <a href="#Sigsuspend">Sigsuspend</a>.
 
 <br><dt><code>int SIGSYS</code>
 <dd>
-<code>signal.h</code> (Unix):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (Unix):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int SIGTERM</code>
 <dd>
-<code>signal.h</code> (ISO):  <a href="#Termination%20Signals">Termination Signals</a>.
+<code>signal.h</code> (ISO):  <a href="#Termination Signals">Termination Signals</a>.
 
 <br><dt><code>int SIGTRAP</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Program%20Error%20Signals">Program Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Program Error Signals">Program Error Signals</a>.
 
 <br><dt><code>int SIGTSTP</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Job%20Control%20Signals">Job Control Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Job Control Signals">Job Control Signals</a>.
 
 <br><dt><code>int SIGTTIN</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Job%20Control%20Signals">Job Control Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Job Control Signals">Job Control Signals</a>.
 
 <br><dt><code>int SIGTTOU</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Job%20Control%20Signals">Job Control Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Job Control Signals">Job Control Signals</a>.
 
 <br><dt><code>SIG_UNBLOCK</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Process%20Signal%20Mask">Process Signal Mask</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Process Signal Mask">Process Signal Mask</a>.
 
 <br><dt><code>int SIGURG</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>.
 
 <br><dt><code>int SIGUSR1</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Miscellaneous Signals">Miscellaneous Signals</a>.
 
 <br><dt><code>int SIGUSR2</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Miscellaneous Signals">Miscellaneous Signals</a>.
 
 <br><dt><code>int sigvec (int <var>signum</var>, const struct sigvec *<var>action</var>,struct sigvec *<var>old-action</var>)</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#BSD%20Handler">BSD Handler</a>.
+<code>signal.h</code> (BSD):  <a href="#BSD Handler">BSD Handler</a>.
 
 <br><dt><code>int SIGVTALRM</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Alarm%20Signals">Alarm Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Alarm Signals">Alarm Signals</a>.
 
 <br><dt><code>int SIGWINCH</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Miscellaneous Signals">Miscellaneous Signals</a>.
 
 <br><dt><code>int SIGXCPU</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Operation%20Error%20Signals">Operation Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Operation Error Signals">Operation Error Signals</a>.
 
 <br><dt><code>int SIGXFSZ</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Operation%20Error%20Signals">Operation Error Signals</a>.
+<code>signal.h</code> (BSD):  <a href="#Operation Error Signals">Operation Error Signals</a>.
 
 <br><dt><code>double sin (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>void sincos (double <var>x</var>, double *<var>sinx</var>, double *<var>cosx</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (GNU):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>void sincosf (float <var>x</var>, float *<var>sinx</var>, float *<var>cosx</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (GNU):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>void sincosl (long double <var>x</var>, long double *<var>sinx</var>, long double *<var>cosx</var>)</code>
 <dd>
-<code>math.h</code> (GNU):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (GNU):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>float sinf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>double sinh (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>float sinhf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double sinhl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double sinl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>S_IREAD</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IRGRP</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IROTH</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IRUSR</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IRWXG</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IRWXO</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IRWXU</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>int S_ISBLK (mode_t <var>m</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_ISCHR (mode_t <var>m</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_ISDIR (mode_t <var>m</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_ISFIFO (mode_t <var>m</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_ISGID</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>int S_ISLNK (mode_t <var>m</var>)</code>
 <dd>
-<code>sys/stat.h</code> (GNU):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (GNU):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_ISREG (mode_t <var>m</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_ISSOCK (mode_t <var>m</var>)</code>
 <dd>
-<code>sys/stat.h</code> (GNU):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (GNU):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>S_ISUID</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_ISVTX</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IWGRP</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IWOTH</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IWRITE</code>
 <dd>
-<code>sys/stat.h</code> (BSD):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (BSD):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IWUSR</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IXGRP</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IXOTH</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>S_IXUSR</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission%20Bits">Permission Bits</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Permission Bits">Permission Bits</a>.
 
 <br><dt><code>size_t</code>
 <dd>
-<code>stddef.h</code> (ISO):  <a href="#Important%20Data%20Types">Important Data Types</a>.
+<code>stddef.h</code> (ISO):  <a href="#Important Data Types">Important Data Types</a>.
 
 <br><dt><code>unsigned int sleep (unsigned int <var>seconds</var>)</code>
 <dd>
 <code>unistd.h</code> (POSIX.1):  <a href="#Sleeping">Sleeping</a>.
 
 <br><dt><code>int snprintf (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>.
+<code>stdio.h</code> (GNU):  <a href="#Formatted Output Functions">Formatted Output Functions</a>.
 
 <br><dt><code>SO_BROADCAST</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>int SOCK_DGRAM</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Communication%20Styles">Communication Styles</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Communication Styles">Communication Styles</a>.
 
 <br><dt><code>int socket (int <var>namespace</var>, int <var>style</var>, int <var>protocol</var>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Creating%20a%20Socket">Creating a Socket</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Creating a Socket">Creating a Socket</a>.
 
 <br><dt><code>int socketpair (int <var>namespace</var>, int <var>style</var>, int <var>protocol</var>, int <var>filedes</var><tt>[2]</tt>)</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket%20Pairs">Socket Pairs</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket Pairs">Socket Pairs</a>.
 
 <br><dt><code>int SOCK_RAW</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Communication%20Styles">Communication Styles</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Communication Styles">Communication Styles</a>.
 
 <br><dt><code>int SOCK_RDM</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Communication%20Styles">Communication Styles</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Communication Styles">Communication Styles</a>.
 
 <br><dt><code>int SOCK_SEQPACKET</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Communication%20Styles">Communication Styles</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Communication Styles">Communication Styles</a>.
 
 <br><dt><code>int SOCK_STREAM</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Communication%20Styles">Communication Styles</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Communication Styles">Communication Styles</a>.
 
 <br><dt><code>SO_DEBUG</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_DONTROUTE</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_ERROR</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_KEEPALIVE</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_LINGER</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>int SOL_SOCKET</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_OOBINLINE</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_RCVBUF</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_REUSEADDR</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_SNDBUF</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_STYLE</code>
 <dd>
-<code>sys/socket.h</code> (GNU):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (GNU):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>SO_TYPE</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>speed_t</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Speed">Line Speed</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Speed">Line Speed</a>.
 
 <br><dt><code>int sprintf (char *<var>s</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>.
+<code>stdio.h</code> (ISO):  <a href="#Formatted Output Functions">Formatted Output Functions</a>.
 
 <br><dt><code>double sqrt (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>float sqrtf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>long double sqrtl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>.
+<code>math.h</code> (ISO):  <a href="#Exponents and Logarithms">Exponents and Logarithms</a>.
 
 <br><dt><code>void srand (unsigned int <var>seed</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#ISO%20Random">ISO Random</a>.
+<code>stdlib.h</code> (ISO):  <a href="#ISO Random">ISO Random</a>.
 
 <br><dt><code>void srand48 (long int <var>seedval</var>)</code>
 <dd>
-<code>stdlib.h</code> (SVID):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (SVID):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>int srand48_r (long int <var>seedval</var>, struct drand48_data *<var>buffer</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#SVID%20Random">SVID Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#SVID Random">SVID Random</a>.
 
 <br><dt><code>void srandom (unsigned int <var>seed</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (BSD):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>int srandom_r (unsigned int <var>seed</var>, struct random_data *<var>buf</var>)</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>int sscanf (const char *<var>s</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>.
+<code>stdio.h</code> (ISO):  <a href="#Formatted Input Functions">Formatted Input Functions</a>.
 
 <br><dt><code>sighandler_t ssignal (int <var>signum</var>, sighandler_t <var>action</var>)</code>
 <dd>
-<code>signal.h</code> (SVID):  <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>.
+<code>signal.h</code> (SVID):  <a href="#Basic Signal Handling">Basic Signal Handling</a>.
 
 <br><dt><code>int SSIZE_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>ssize_t</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <br><dt><code>stack_t</code>
 <dd>
-<code>signal.h</code> (XPG):  <a href="#Signal%20Stack">Signal Stack</a>.
+<code>signal.h</code> (XPG):  <a href="#Signal Stack">Signal Stack</a>.
 
 <br><dt><code>int stat (const char *<var>filename</var>, struct stat *<var>buf</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Reading%20Attributes">Reading Attributes</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Reading Attributes">Reading Attributes</a>.
 
 <br><dt><code>int stat64 (const char *<var>filename</var>, struct stat64 *<var>buf</var>)</code>
 <dd>
-<code>sys/stat.h</code> (Unix98):  <a href="#Reading%20Attributes">Reading Attributes</a>.
+<code>sys/stat.h</code> (Unix98):  <a href="#Reading Attributes">Reading Attributes</a>.
 
 <br><dt><code>FILE * stderr</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Standard%20Streams">Standard Streams</a>.
+<code>stdio.h</code> (ISO):  <a href="#Standard Streams">Standard Streams</a>.
 
 <br><dt><code>STDERR_FILENO</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Descriptors and Streams">Descriptors and Streams</a>.
 
 <br><dt><code>FILE * stdin</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Standard%20Streams">Standard Streams</a>.
+<code>stdio.h</code> (ISO):  <a href="#Standard Streams">Standard Streams</a>.
 
 <br><dt><code>STDIN_FILENO</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Descriptors and Streams">Descriptors and Streams</a>.
 
 <br><dt><code>FILE * stdout</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Standard%20Streams">Standard Streams</a>.
+<code>stdio.h</code> (ISO):  <a href="#Standard Streams">Standard Streams</a>.
 
 <br><dt><code>STDOUT_FILENO</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Descriptors and Streams">Descriptors and Streams</a>.
 
 <br><dt><code>int stime (time_t *<var>newtime</var>)</code>
 <dd>
-<code>time.h</code> (SVID, XPG):  <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>.
+<code>time.h</code> (SVID, XPG):  <a href="#Simple Calendar Time">Simple Calendar Time</a>.
 
 <br><dt><code>char * stpcpy (char *restrict <var>to</var>, const char *restrict <var>from</var>)</code>
 <dd>
-<code>string.h</code> (Unknown origin):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (Unknown origin):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>char * stpncpy (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>int strcasecmp (const char *<var>s1</var>, const char *<var>s2</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>string.h</code> (BSD):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>char * strcasestr (const char *<var>haystack</var>, const char *<var>needle</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (GNU):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>char * strcat (char *restrict <var>to</var>, const char *restrict <var>from</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>char * strchr (const char *<var>string</var>, int <var>c</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>char * strchrnul (const char *<var>string</var>, int <var>c</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (GNU):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>int strcmp (const char *<var>s1</var>, const char *<var>s2</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>string.h</code> (ISO):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>int strcoll (const char *<var>s1</var>, const char *<var>s2</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Collation%20Functions">Collation Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Collation Functions">Collation Functions</a>.
 
 <br><dt><code>char * strcpy (char *restrict <var>to</var>, const char *restrict <var>from</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>size_t strcspn (const char *<var>string</var>, const char *<var>stopset</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>char * strdup (const char *<var>s</var>)</code>
 <dd>
-<code>string.h</code> (SVID):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (SVID):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>char * strdupa (const char *<var>s</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>int STREAM_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>char * strerror (int <var>errnum</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Error%20Messages">Error Messages</a>.
+<code>string.h</code> (ISO):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>char * strerror_r (int <var>errnum</var>, char *<var>buf</var>, size_t <var>n</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Error%20Messages">Error Messages</a>.
+<code>string.h</code> (GNU):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>char * strfry (char *<var>string</var>)</code>
 <dd>
 <code>string.h</code> (GNU):  <a href="#strfry">strfry</a>.
 
 <br><dt><code>size_t strftime (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, const struct tm *<var>brokentime</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>.
+<code>time.h</code> (ISO):  <a href="#Formatting Calendar Time">Formatting Calendar Time</a>.
 
 <br><dt><code>size_t strlen (const char *<var>s</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#String%20Length">String Length</a>.
+<code>string.h</code> (ISO):  <a href="#String Length">String Length</a>.
 
 <br><dt><code>int strncasecmp (const char *<var>s1</var>, const char *<var>s2</var>, size_t <var>n</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>string.h</code> (BSD):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>char * strncat (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>int strncmp (const char *<var>s1</var>, const char *<var>s2</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>string.h</code> (ISO):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>char * strncpy (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>char * strndup (const char *<var>s</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>char * strndupa (const char *<var>s</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>string.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>size_t strnlen (const char *<var>s</var>, size_t <var>maxlen</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#String%20Length">String Length</a>.
+<code>string.h</code> (GNU):  <a href="#String Length">String Length</a>.
 
 <br><dt><code>char * strpbrk (const char *<var>string</var>, const char *<var>stopset</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>char * strptime (const char *<var>s</var>, const char *<var>fmt</var>, struct tm *<var>tp</var>)</code>
 <dd>
-<code>time.h</code> (XPG4):  <a href="#Low-Level%20Time%20String%20Parsing">Low-Level Time String Parsing</a>.
+<code>time.h</code> (XPG4):  <a href="#Low-Level Time String Parsing">Low-Level Time String Parsing</a>.
 
 <br><dt><code>char * strrchr (const char *<var>string</var>, int <var>c</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>char * strsep (char **<var>string_ptr</var>, const char *<var>delimiter</var>)</code>
 <dd>
-<code>string.h</code> (BSD):  <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>.
+<code>string.h</code> (BSD):  <a href="#Finding Tokens in a String">Finding Tokens in a String</a>.
 
 <br><dt><code>char * strsignal (int <var>signum</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#Signal%20Messages">Signal Messages</a>.
+<code>string.h</code> (GNU):  <a href="#Signal Messages">Signal Messages</a>.
 
 <br><dt><code>size_t strspn (const char *<var>string</var>, const char *<var>skipset</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>char * strstr (const char *<var>haystack</var>, const char *<var>needle</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>double strtod (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Floats">Parsing of Floats</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Floats">Parsing of Floats</a>.
 
 <br><dt><code>float strtof (const char *<var>string</var>, char **<var>tailptr</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Floats">Parsing of Floats</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Floats">Parsing of Floats</a>.
 
 <br><dt><code>intmax_t strtoimax (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>inttypes.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>inttypes.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>char * strtok (char *restrict <var>newstring</var>, const char *restrict <var>delimiters</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>.
+<code>string.h</code> (ISO):  <a href="#Finding Tokens in a String">Finding Tokens in a String</a>.
 
 <br><dt><code>char * strtok_r (char *<var>newstring</var>, const char *<var>delimiters</var>, char **<var>save_ptr</var>)</code>
 <dd>
-<code>string.h</code> (POSIX):  <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>.
+<code>string.h</code> (POSIX):  <a href="#Finding Tokens in a String">Finding Tokens in a String</a>.
 
 <br><dt><code>long int strtol (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>long double strtold (const char *<var>string</var>, char **<var>tailptr</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Floats">Parsing of Floats</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Floats">Parsing of Floats</a>.
 
 <br><dt><code>long long int strtoll (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>long long int strtoq (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (BSD):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>unsigned long int strtoul (const char *retrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>unsigned long long int strtoull (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>uintmax_t strtoumax (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>inttypes.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>inttypes.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>unsigned long long int strtouq (const char *restrict <var>string</var>, char **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>stdlib.h</code> (BSD):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>struct aiocb</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous I%2fO">Asynchronous I/O</a>.
 
 <br><dt><code>struct aiocb64</code>
 <dd>
-<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>.
+<code>aio.h</code> (POSIX.1b):  <a href="#Asynchronous I%2fO">Asynchronous I/O</a>.
 
 <br><dt><code>struct aioinit</code>
 <dd>
-<code>aio.h</code> (GNU):  <a href="#Configuration%20of%20AIO">Configuration of AIO</a>.
+<code>aio.h</code> (GNU):  <a href="#Configuration of AIO">Configuration of AIO</a>.
 
 <br><dt><code>struct argp</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Parsers">Argp Parsers</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Parsers">Argp Parsers</a>.
 
 <br><dt><code>struct argp_child</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Children">Argp Children</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Children">Argp Children</a>.
 
 <br><dt><code>struct argp_option</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Option Vectors">Argp Option Vectors</a>.
 
 <br><dt><code>struct argp_state</code>
 <dd>
-<code>argp.h</code> (GNU):  <a href="#Argp%20Parsing%20State">Argp Parsing State</a>.
+<code>argp.h</code> (GNU):  <a href="#Argp Parsing State">Argp Parsing State</a>.
 
 <br><dt><code>struct dirent</code>
 <dd>
-<code>dirent.h</code> (POSIX.1):  <a href="#Directory%20Entries">Directory Entries</a>.
+<code>dirent.h</code> (POSIX.1):  <a href="#Directory Entries">Directory Entries</a>.
 
 <br><dt><code>struct exit_status</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>struct flock</code>
 <dd>
-<code>fcntl.h</code> (POSIX.1):  <a href="#File%20Locks">File Locks</a>.
+<code>fcntl.h</code> (POSIX.1):  <a href="#File Locks">File Locks</a>.
 
 <br><dt><code>struct fstab</code>
 <dd>
 <code>fstab.h</code> (BSD):  <a href="#fstab">fstab</a>.
 
 <br><dt><code>struct FTW</code>
 <dd>
-<code>ftw.h</code> (XPG4.2):  <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>.
+<code>ftw.h</code> (XPG4.2):  <a href="#Working with Directory Trees">Working with Directory Trees</a>.
 
 <br><dt><code>struct __gconv_step</code>
 <dd>
-<code>gconv.h</code> (GNU):  <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>.
+<code>gconv.h</code> (GNU):  <a href="#glibc iconv Implementation">glibc iconv Implementation</a>.
 
 <br><dt><code>struct __gconv_step_data</code>
 <dd>
-<code>gconv.h</code> (GNU):  <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>.
+<code>gconv.h</code> (GNU):  <a href="#glibc iconv Implementation">glibc iconv Implementation</a>.
 
 <br><dt><code>struct group</code>
 <dd>
-<code>grp.h</code> (POSIX.1):  <a href="#Group%20Data%20Structure">Group Data Structure</a>.
+<code>grp.h</code> (POSIX.1):  <a href="#Group Data Structure">Group Data Structure</a>.
 
 <br><dt><code>struct hostent</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>struct if_nameindex</code>
 <dd>
-<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface%20Naming">Interface Naming</a>.
+<code>net/if.h</code> (IPv6 basic API):  <a href="#Interface Naming">Interface Naming</a>.
 
 <br><dt><code>struct in6_addr</code>
 <dd>
-<code>netinet/in.h</code> (IPv6 basic API):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (IPv6 basic API):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>struct in_addr</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Host Address Data Type">Host Address Data Type</a>.
 
 <br><dt><code>struct iovec</code>
 <dd>
 <code>sys/uio.h</code> (BSD):  <a href="#Scatter-Gather">Scatter-Gather</a>.
 
 <br><dt><code>struct itimerval</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#Setting%20an%20Alarm">Setting an Alarm</a>.
+<code>sys/time.h</code> (BSD):  <a href="#Setting an Alarm">Setting an Alarm</a>.
 
 <br><dt><code>struct lconv</code>
 <dd>
-<code>locale.h</code> (ISO):  <a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>.
+<code>locale.h</code> (ISO):  <a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>.
 
 <br><dt><code>struct linger</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level%20Options">Socket-Level Options</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Socket-Level Options">Socket-Level Options</a>.
 
 <br><dt><code>struct mallinfo</code>
 <dd>
-<code>malloc.h</code> (GNU):  <a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>.
+<code>malloc.h</code> (GNU):  <a href="#Statistics of Malloc">Statistics of Malloc</a>.
 
 <br><dt><code>struct mntent</code>
 <dd>
 <code>mntent.h</code> (BSD):  <a href="#mtab">mtab</a>.
 
 <br><dt><code>struct msghdr</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Receiving%20Datagrams">Receiving Datagrams</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Receiving Datagrams">Receiving Datagrams</a>.
 
 <br><dt><code>struct netent</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Networks%20Database">Networks Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Networks Database">Networks Database</a>.
 
 <br><dt><code>struct obstack</code>
 <dd>
-<code>obstack.h</code> (GNU):  <a href="#Creating%20Obstacks">Creating Obstacks</a>.
+<code>obstack.h</code> (GNU):  <a href="#Creating Obstacks">Creating Obstacks</a>.
 
 <br><dt><code>struct option</code>
 <dd>
-<code>getopt.h</code> (GNU):  <a href="#Getopt%20Long%20Options">Getopt Long Options</a>.
+<code>getopt.h</code> (GNU):  <a href="#Getopt Long Options">Getopt Long Options</a>.
 
 <br><dt><code>struct passwd</code>
 <dd>
-<code>pwd.h</code> (POSIX.1):  <a href="#User%20Data%20Structure">User Data Structure</a>.
+<code>pwd.h</code> (POSIX.1):  <a href="#User Data Structure">User Data Structure</a>.
 
 <br><dt><code>struct printf_info</code>
 <dd>
-<code>printf.h</code> (GNU):  <a href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>.
+<code>printf.h</code> (GNU):  <a href="#Conversion Specifier Options">Conversion Specifier Options</a>.
 
 <br><dt><code>struct protoent</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Protocols%20Database">Protocols Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Protocols Database">Protocols Database</a>.
 
 <br><dt><code>struct random_data</code>
 <dd>
-<code>stdlib.h</code> (GNU):  <a href="#BSD%20Random">BSD Random</a>.
+<code>stdlib.h</code> (GNU):  <a href="#BSD Random">BSD Random</a>.
 
 <br><dt><code>struct rlimit</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>struct rlimit64</code>
 <dd>
-<code>sys/resource.h</code> (Unix98):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/resource.h</code> (Unix98):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>struct rusage</code>
 <dd>
-<code>sys/resource.h</code> (BSD):  <a href="#Resource%20Usage">Resource Usage</a>.
+<code>sys/resource.h</code> (BSD):  <a href="#Resource Usage">Resource Usage</a>.
 
 <br><dt><code>struct sched_param</code>
 <dd>
-<code>sched.h</code> (POSIX):  <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>.
+<code>sched.h</code> (POSIX):  <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>.
 
 <br><dt><code>struct servent</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Services%20Database">Services Database</a>.
+<code>netdb.h</code> (BSD):  <a href="#Services Database">Services Database</a>.
 
 <br><dt><code>struct sgttyb</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>.
+<code>termios.h</code> (BSD):  <a href="#BSD Terminal Modes">BSD Terminal Modes</a>.
 
 <br><dt><code>struct sigaction</code>
 <dd>
-<code>signal.h</code> (POSIX.1):  <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>.
+<code>signal.h</code> (POSIX.1):  <a href="#Advanced Signal Handling">Advanced Signal Handling</a>.
 
 <br><dt><code>struct sigstack</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#Signal%20Stack">Signal Stack</a>.
+<code>signal.h</code> (BSD):  <a href="#Signal Stack">Signal Stack</a>.
 
 <br><dt><code>struct sigvec</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#BSD%20Handler">BSD Handler</a>.
+<code>signal.h</code> (BSD):  <a href="#BSD Handler">BSD Handler</a>.
 
 <br><dt><code>struct sockaddr</code>
 <dd>
-<code>sys/socket.h</code> (BSD):  <a href="#Address%20Formats">Address Formats</a>.
+<code>sys/socket.h</code> (BSD):  <a href="#Address Formats">Address Formats</a>.
 
 <br><dt><code>struct sockaddr_in</code>
 <dd>
-<code>netinet/in.h</code> (BSD):  <a href="#Internet%20Address%20Formats">Internet Address Formats</a>.
+<code>netinet/in.h</code> (BSD):  <a href="#Internet Address Formats">Internet Address Formats</a>.
 
 <br><dt><code>struct sockaddr_un</code>
 <dd>
-<code>sys/un.h</code> (BSD):  <a href="#Local%20Namespace%20Details">Local Namespace Details</a>.
+<code>sys/un.h</code> (BSD):  <a href="#Local Namespace Details">Local Namespace Details</a>.
 
 <br><dt><code>struct stat</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>struct stat64</code>
 <dd>
-<code>sys/stat.h</code> (LFS):  <a href="#Attribute%20Meanings">Attribute Meanings</a>.
+<code>sys/stat.h</code> (LFS):  <a href="#Attribute Meanings">Attribute Meanings</a>.
 
 <br><dt><code>struct termios</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Data%20Types">Mode Data Types</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Data Types">Mode Data Types</a>.
 
 <br><dt><code>struct timespec</code>
 <dd>
-<code>sys/time.h</code> (POSIX.1):  <a href="#Elapsed%20Time">Elapsed Time</a>.
+<code>sys/time.h</code> (POSIX.1):  <a href="#Elapsed Time">Elapsed Time</a>.
 
 <br><dt><code>struct timeval</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#Elapsed%20Time">Elapsed Time</a>.
+<code>sys/time.h</code> (BSD):  <a href="#Elapsed Time">Elapsed Time</a>.
 
 <br><dt><code>struct timezone</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>.
+<code>sys/time.h</code> (BSD):  <a href="#High-Resolution Calendar">High-Resolution Calendar</a>.
 
 <br><dt><code>struct tm</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (ISO):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>struct tms</code>
 <dd>
-<code>sys/times.h</code> (POSIX.1):  <a href="#Processor%20Time">Processor Time</a>.
+<code>sys/times.h</code> (POSIX.1):  <a href="#Processor Time">Processor Time</a>.
 
 <br><dt><code>struct utimbuf</code>
 <dd>
-<code>time.h</code> (POSIX.1):  <a href="#File%20Times">File Times</a>.
+<code>time.h</code> (POSIX.1):  <a href="#File Times">File Times</a>.
 
 <br><dt><code>struct utsname</code>
 <dd>
-<code>sys/utsname.h</code> (POSIX.1):  <a href="#Platform%20Type">Platform Type</a>.
+<code>sys/utsname.h</code> (POSIX.1):  <a href="#Platform Type">Platform Type</a>.
 
 <br><dt><code>int strverscmp (const char *<var>s1</var>, const char *<var>s2</var>)</code>
 <dd>
-<code>string.h</code> (GNU):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>string.h</code> (GNU):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>size_t strxfrm (char *restrict <var>to</var>, const char *restrict <var>from</var>, size_t <var>size</var>)</code>
 <dd>
-<code>string.h</code> (ISO):  <a href="#Collation%20Functions">Collation Functions</a>.
+<code>string.h</code> (ISO):  <a href="#Collation Functions">Collation Functions</a>.
 
 <br><dt><code>int stty (int <var>filedes</var>, struct sgttyb * attributes)</code>
 <dd>
-<code>sgtty.h</code> (BSD):  <a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>.
+<code>sgtty.h</code> (BSD):  <a href="#BSD Terminal Modes">BSD Terminal Modes</a>.
 
 <br><dt><code>int S_TYPEISMQ (struct stat *<var>s</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_TYPEISSEM (struct stat *<var>s</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int S_TYPEISSHM (struct stat *<var>s</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX):  <a href="#Testing%20File%20Type">Testing File Type</a>.
+<code>sys/stat.h</code> (POSIX):  <a href="#Testing File Type">Testing File Type</a>.
 
 <br><dt><code>int SUN_LEN (<em>struct sockaddr_un *</em> <var>ptr</var>)</code>
 <dd>
-<code>sys/un.h</code> (BSD):  <a href="#Local%20Namespace%20Details">Local Namespace Details</a>.
+<code>sys/un.h</code> (BSD):  <a href="#Local Namespace Details">Local Namespace Details</a>.
 
 <br><dt><code>_SVID_SOURCE</code>
 <dd>
-(GNU):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(GNU):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>int SV_INTERRUPT</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#BSD%20Handler">BSD Handler</a>.
+<code>signal.h</code> (BSD):  <a href="#BSD Handler">BSD Handler</a>.
 
 <br><dt><code>int SV_ONSTACK</code>
 <dd>
-<code>signal.h</code> (BSD):  <a href="#BSD%20Handler">BSD Handler</a>.
+<code>signal.h</code> (BSD):  <a href="#BSD Handler">BSD Handler</a>.
 
 <br><dt><code>int SV_RESETHAND</code>
 <dd>
-<code>signal.h</code> (Sun):  <a href="#BSD%20Handler">BSD Handler</a>.
+<code>signal.h</code> (Sun):  <a href="#BSD Handler">BSD Handler</a>.
 
 <br><dt><code>int swapcontext (ucontext_t *restrict <var>oucp</var>, const ucontext_t *restrict <var>ucp</var>)</code>
 <dd>
-<code>ucontext.h</code> (SVID):  <a href="#System%20V%20contexts">System V contexts</a>.
+<code>ucontext.h</code> (SVID):  <a href="#System V contexts">System V contexts</a>.
 
 <br><dt><code>int swprintf (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>.
+<code>wchar.h</code> (GNU):  <a href="#Formatted Output Functions">Formatted Output Functions</a>.
 
 <br><dt><code>int swscanf (const wchar_t *<var>ws</var>, const char *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Formatted Input Functions">Formatted Input Functions</a>.
 
 <br><dt><code>int symlink (const char *<var>oldname</var>, const char *<var>newname</var>)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Symbolic%20Links">Symbolic Links</a>.
+<code>unistd.h</code> (BSD):  <a href="#Symbolic Links">Symbolic Links</a>.
 
 <br><dt><code>SYMLINK_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#File%20Minimums">File Minimums</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#File Minimums">File Minimums</a>.
 
 <br><dt><code>int sync (void)</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>.
+<code>unistd.h</code> (X/Open):  <a href="#Synchronizing I%2fO">Synchronizing I/O</a>.
 
 <br><dt><code>long int syscall (long int <var>sysno</var>, ...)</code>
 <dd>
-<code>unistd.h</code> (???):  <a href="#System%20Calls">System Calls</a>.
+<code>unistd.h</code> (???):  <a href="#System Calls">System Calls</a>.
 
 <br><dt><code>long int sysconf (int <var>parameter</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Sysconf%20Definition">Sysconf Definition</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Sysconf Definition">Sysconf Definition</a>.
 
 <br><dt><code>int sysctl (int *<var>names</var>, int <var>nlen</var>, void *<var>oldval</var>,</code>
 <dd>
-<code>sysctl.h</code> (BSD):  <a href="#System%20Parameters">System Parameters</a>.
+<code>sysctl.h</code> (BSD):  <a href="#System Parameters">System Parameters</a>.
 
 <br><dt><code>void syslog (int <var>facility_priority</var>, char *<var>format</var>, ...)</code>
 <dd>
-<code>syslog.h</code> (BSD):  <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>.
+<code>syslog.h</code> (BSD):  <a href="#syslog%3b vsyslog">syslog; vsyslog</a>.
 
 <br><dt><code>int system (const char *<var>command</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Running%20a%20Command">Running a Command</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Running a Command">Running a Command</a>.
 
 <br><dt><code>sighandler_t sysv_signal (int <var>signum</var>, sighandler_t <var>action</var>)</code>
 <dd>
-<code>signal.h</code> (GNU):  <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>.
+<code>signal.h</code> (GNU):  <a href="#Basic Signal Handling">Basic Signal Handling</a>.
 
 <br><dt><code>double tan (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>float tanf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>double tanh (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>float tanhf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double tanhl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Hyperbolic Functions">Hyperbolic Functions</a>.
 
 <br><dt><code>long double tanl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Trig%20Functions">Trig Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Trig Functions">Trig Functions</a>.
 
 <br><dt><code>int tcdrain (int <var>filedes</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Control">Line Control</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Control">Line Control</a>.
 
 <br><dt><code>tcflag_t</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Data%20Types">Mode Data Types</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Data Types">Mode Data Types</a>.
 
 <br><dt><code>int tcflow (int <var>filedes</var>, int <var>action</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Control">Line Control</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Control">Line Control</a>.
 
 <br><dt><code>int tcflush (int <var>filedes</var>, int <var>queue</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Control">Line Control</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Control">Line Control</a>.
 
 <br><dt><code>int tcgetattr (int <var>filedes</var>, struct termios *<var>termios-p</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Functions">Mode Functions</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Functions">Mode Functions</a>.
 
 <br><dt><code>pid_t tcgetpgrp (int <var>filedes</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Terminal Access Functions">Terminal Access Functions</a>.
 
 <br><dt><code>pid_t tcgetsid (int <var>fildes</var>)</code>
 <dd>
-<code>termios.h</code> (Unix98):  <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>.
+<code>termios.h</code> (Unix98):  <a href="#Terminal Access Functions">Terminal Access Functions</a>.
 
 <br><dt><code>TCSADRAIN</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Functions">Mode Functions</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Functions">Mode Functions</a>.
 
 <br><dt><code>TCSAFLUSH</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Functions">Mode Functions</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Functions">Mode Functions</a>.
 
 <br><dt><code>TCSANOW</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Functions">Mode Functions</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Functions">Mode Functions</a>.
 
 <br><dt><code>TCSASOFT</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Mode%20Functions">Mode Functions</a>.
+<code>termios.h</code> (BSD):  <a href="#Mode Functions">Mode Functions</a>.
 
 <br><dt><code>int tcsendbreak (int <var>filedes</var>, int <var>duration</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Line%20Control">Line Control</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Line Control">Line Control</a>.
 
 <br><dt><code>int tcsetattr (int <var>filedes</var>, int <var>when</var>, const struct termios *<var>termios-p</var>)</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Mode%20Functions">Mode Functions</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Mode Functions">Mode Functions</a>.
 
 <br><dt><code>int tcsetpgrp (int <var>filedes</var>, pid_t <var>pgid</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Terminal Access Functions">Terminal Access Functions</a>.
 
 <br><dt><code>void * tdelete (const void *<var>key</var>, void **<var>rootp</var>, comparison_fn_t <var>compar</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Tree%20Search%20Function">Tree Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Tree Search Function">Tree Search Function</a>.
 
 <br><dt><code>void tdestroy (void *<var>vroot</var>, __free_fn_t <var>freefct</var>)</code>
 <dd>
-<code>search.h</code> (GNU):  <a href="#Tree%20Search%20Function">Tree Search Function</a>.
+<code>search.h</code> (GNU):  <a href="#Tree Search Function">Tree Search Function</a>.
 
 <br><dt><code>off_t telldir (DIR *<var>dirstream</var>)</code>
 <dd>
-<code>dirent.h</code> (BSD):  <a href="#Random%20Access%20Directory">Random Access Directory</a>.
+<code>dirent.h</code> (BSD):  <a href="#Random Access Directory">Random Access Directory</a>.
 
 <br><dt><code>TEMP_FAILURE_RETRY (<var>expression</var>)</code>
 <dd>
-<code>unistd.h</code> (GNU):  <a href="#Interrupted%20Primitives">Interrupted Primitives</a>.
+<code>unistd.h</code> (GNU):  <a href="#Interrupted Primitives">Interrupted Primitives</a>.
 
 <br><dt><code>char * tempnam (const char *<var>dir</var>, const char *<var>prefix</var>)</code>
 <dd>
-<code>stdio.h</code> (SVID):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (SVID):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>char * textdomain (const char *<var>domainname</var>)</code>
 <dd>
-<code>libintl.h</code> (GNU):  <a href="#Locating%20gettext%20catalog">Locating gettext catalog</a>.
+<code>libintl.h</code> (GNU):  <a href="#Locating gettext catalog">Locating gettext catalog</a>.
 
 <br><dt><code>void * tfind (const void *<var>key</var>, void *const *<var>rootp</var>, comparison_fn_t <var>compar</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Tree%20Search%20Function">Tree Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Tree Search Function">Tree Search Function</a>.
 
 <br><dt><code>double tgamma (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (XPG, ISO):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (XPG, ISO):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float tgammaf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (XPG, ISO):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (XPG, ISO):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double tgammal (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (XPG, ISO):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (XPG, ISO):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>time_t time (time_t *<var>result</var>)</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>.
+<code>time.h</code> (ISO):  <a href="#Simple Calendar Time">Simple Calendar Time</a>.
 
 <br><dt><code>time_t timegm (struct tm *<var>brokentime</var>)</code>
 <dd>
-<code>time.h</code> (???):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (???):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>time_t timelocal (struct tm *<var>brokentime</var>)</code>
 <dd>
-<code>time.h</code> (???):  <a href="#Broken-down%20Time">Broken-down Time</a>.
+<code>time.h</code> (???):  <a href="#Broken-down Time">Broken-down Time</a>.
 
 <br><dt><code>clock_t times (struct tms *<var>buffer</var>)</code>
 <dd>
-<code>sys/times.h</code> (POSIX.1):  <a href="#Processor%20Time">Processor Time</a>.
+<code>sys/times.h</code> (POSIX.1):  <a href="#Processor Time">Processor Time</a>.
 
 <br><dt><code>time_t</code>
 <dd>
-<code>time.h</code> (ISO):  <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>.
+<code>time.h</code> (ISO):  <a href="#Simple Calendar Time">Simple Calendar Time</a>.
 
 <br><dt><code>long int timezone</code>
 <dd>
-<code>time.h</code> (SVID):  <a href="#Time%20Zone%20Functions">Time Zone Functions</a>.
+<code>time.h</code> (SVID):  <a href="#Time Zone Functions">Time Zone Functions</a>.
 
 <br><dt><code>FILE * tmpfile (void)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (ISO):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>FILE * tmpfile64 (void)</code>
 <dd>
-<code>stdio.h</code> (Unix98):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (Unix98):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>int TMP_MAX</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (ISO):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>char * tmpnam (char *<var>result</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (ISO):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>char * tmpnam_r (char *<var>result</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Temporary%20Files">Temporary Files</a>.
+<code>stdio.h</code> (GNU):  <a href="#Temporary Files">Temporary Files</a>.
 
 <br><dt><code>int toascii (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (SVID, BSD):  <a href="#Case%20Conversion">Case Conversion</a>.
+<code>ctype.h</code> (SVID, BSD):  <a href="#Case Conversion">Case Conversion</a>.
 
 <br><dt><code>int _tolower (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (SVID):  <a href="#Case%20Conversion">Case Conversion</a>.
+<code>ctype.h</code> (SVID):  <a href="#Case Conversion">Case Conversion</a>.
 
 <br><dt><code>int tolower (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Case%20Conversion">Case Conversion</a>.
+<code>ctype.h</code> (ISO):  <a href="#Case Conversion">Case Conversion</a>.
 
 <br><dt><code>tcflag_t TOSTOP</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Local%20Modes">Local Modes</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Local Modes">Local Modes</a>.
 
 <br><dt><code>int _toupper (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (SVID):  <a href="#Case%20Conversion">Case Conversion</a>.
+<code>ctype.h</code> (SVID):  <a href="#Case Conversion">Case Conversion</a>.
 
 <br><dt><code>int toupper (int <var>c</var>)</code>
 <dd>
-<code>ctype.h</code> (ISO):  <a href="#Case%20Conversion">Case Conversion</a>.
+<code>ctype.h</code> (ISO):  <a href="#Case Conversion">Case Conversion</a>.
 
 <br><dt><code>wint_t towctrans (wint_t <var>wc</var>, wctrans_t <var>desc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>.
+<code>wctype.h</code> (ISO):  <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>.
 
 <br><dt><code>wint_t towlower (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>.
+<code>wctype.h</code> (ISO):  <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>.
 
 <br><dt><code>wint_t towupper (wint_t <var>wc</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>.
+<code>wctype.h</code> (ISO):  <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>.
 
 <br><dt><code>double trunc (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>int truncate (const char *<var>filename</var>, off_t <var>length</var>)</code>
 <dd>
-<code>unistd.h</code> (X/Open):  <a href="#File%20Size">File Size</a>.
+<code>unistd.h</code> (X/Open):  <a href="#File Size">File Size</a>.
 
 <br><dt><code>int truncate64 (const char *<var>name</var>, off64_t <var>length</var>)</code>
 <dd>
-<code>unistd.h</code> (Unix98):  <a href="#File%20Size">File Size</a>.
+<code>unistd.h</code> (Unix98):  <a href="#File Size">File Size</a>.
 
 <br><dt><code>float truncf (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>long double truncl (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (ISO):  <a href="#Rounding%20Functions">Rounding Functions</a>.
+<code>math.h</code> (ISO):  <a href="#Rounding Functions">Rounding Functions</a>.
 
 <br><dt><code>TRY_AGAIN</code>
 <dd>
-<code>netdb.h</code> (BSD):  <a href="#Host%20Names">Host Names</a>.
+<code>netdb.h</code> (BSD):  <a href="#Host Names">Host Names</a>.
 
 <br><dt><code>void * tsearch (const void *<var>key</var>, void **<var>rootp</var>, comparison_fn_t <var>compar</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Tree%20Search%20Function">Tree Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Tree Search Function">Tree Search Function</a>.
 
 <br><dt><code>char * ttyname (int <var>filedes</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Is It a Terminal">Is It a Terminal</a>.
 
 <br><dt><code>int ttyname_r (int <var>filedes</var>, char *<var>buf</var>, size_t <var>len</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Is It a Terminal">Is It a Terminal</a>.
 
 <br><dt><code>void twalk (const void *<var>root</var>, __action_fn_t <var>action</var>)</code>
 <dd>
-<code>search.h</code> (SVID):  <a href="#Tree%20Search%20Function">Tree Search Function</a>.
+<code>search.h</code> (SVID):  <a href="#Tree Search Function">Tree Search Function</a>.
 
 <br><dt><code>char * tzname [2]</code>
 <dd>
-<code>time.h</code> (POSIX.1):  <a href="#Time%20Zone%20Functions">Time Zone Functions</a>.
+<code>time.h</code> (POSIX.1):  <a href="#Time Zone Functions">Time Zone Functions</a>.
 
 <br><dt><code>int TZNAME_MAX</code>
 <dd>
-<code>limits.h</code> (POSIX.1):  <a href="#General%20Limits">General Limits</a>.
+<code>limits.h</code> (POSIX.1):  <a href="#General Limits">General Limits</a>.
 
 <br><dt><code>void tzset (void)</code>
 <dd>
-<code>time.h</code> (POSIX.1):  <a href="#Time%20Zone%20Functions">Time Zone Functions</a>.
+<code>time.h</code> (POSIX.1):  <a href="#Time Zone Functions">Time Zone Functions</a>.
 
 <br><dt><code>UCHAR_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>ucontext_t</code>
 <dd>
-<code>ucontext.h</code> (SVID):  <a href="#System%20V%20contexts">System V contexts</a>.
+<code>ucontext.h</code> (SVID):  <a href="#System V contexts">System V contexts</a>.
 
 <br><dt><code>uid_t</code>
 <dd>
-<code>sys/types.h</code> (POSIX.1):  <a href="#Reading%20Persona">Reading Persona</a>.
+<code>sys/types.h</code> (POSIX.1):  <a href="#Reading Persona">Reading Persona</a>.
 
 <br><dt><code>UINT_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>int ulimit (int <var>cmd</var>, ...)</code>
 <dd>
-<code>ulimit.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>ulimit.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>ULONG_LONG_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>ULONG_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>mode_t umask (mode_t <var>mask</var>)</code>
 <dd>
-<code>sys/stat.h</code> (POSIX.1):  <a href="#Setting%20Permissions">Setting Permissions</a>.
+<code>sys/stat.h</code> (POSIX.1):  <a href="#Setting Permissions">Setting Permissions</a>.
 
 <br><dt><code>int umount (const char *<var>file</var>)</code>
 <dd>
 <code>sys/mount.h</code> (SVID, GNU):  <a href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>.
@@ -85156,688 +83547,688 @@
 <code>sys/mount.h</code> (GNU):  <a href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>.
 
 <br><dt><code>int uname (struct utsname *<var>info</var>)</code>
 <dd>
-<code>sys/utsname.h</code> (POSIX.1):  <a href="#Platform%20Type">Platform Type</a>.
+<code>sys/utsname.h</code> (POSIX.1):  <a href="#Platform Type">Platform Type</a>.
 
 <br><dt><code>int ungetc (int <var>c</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#How%20Unread">How Unread</a>.
+<code>stdio.h</code> (ISO):  <a href="#How Unread">How Unread</a>.
 
 <br><dt><code>wint_t ungetwc (wint_t <var>wc</var>, FILE *<var>stream</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#How%20Unread">How Unread</a>.
+<code>wchar.h</code> (ISO):  <a href="#How Unread">How Unread</a>.
 
 <br><dt><code>union wait</code>
 <dd>
-<code>sys/wait.h</code> (BSD):  <a href="#BSD%20Wait%20Functions">BSD Wait Functions</a>.
+<code>sys/wait.h</code> (BSD):  <a href="#BSD Wait Functions">BSD Wait Functions</a>.
 
 <br><dt><code>int unlink (const char *<var>filename</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Deleting%20Files">Deleting Files</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Deleting Files">Deleting Files</a>.
 
 <br><dt><code>int unlockpt (int <var>filedes</var>)</code>
 <dd>
 <code>stdlib.h</code> (SVID, XPG4.2):  <a href="#Allocation">Allocation</a>.
 
 <br><dt><code>int unsetenv (const char *<var>name</var>)</code>
 <dd>
-<code>stdlib.h</code> (BSD):  <a href="#Environment%20Access">Environment Access</a>.
+<code>stdlib.h</code> (BSD):  <a href="#Environment Access">Environment Access</a>.
 
 <br><dt><code>void updwtmp (const char *<var>wtmp_file</var>, const struct utmp *<var>utmp</var>)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>USER_PROCESS</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>USER_PROCESS</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>USHRT_MAX</code>
 <dd>
-<code>limits.h</code> (ISO):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (ISO):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>int utime (const char *<var>filename</var>, const struct utimbuf *<var>times</var>)</code>
 <dd>
-<code>time.h</code> (POSIX.1):  <a href="#File%20Times">File Times</a>.
+<code>time.h</code> (POSIX.1):  <a href="#File Times">File Times</a>.
 
 <br><dt><code>int utimes (const char *<var>filename</var>, struct timeval <var>tvp</var><tt>[2]</tt>)</code>
 <dd>
-<code>sys/time.h</code> (BSD):  <a href="#File%20Times">File Times</a>.
+<code>sys/time.h</code> (BSD):  <a href="#File Times">File Times</a>.
 
 <br><dt><code>int utmpname (const char *<var>file</var>)</code>
 <dd>
-<code>utmp.h</code> (SVID):  <a href="#Manipulating%20the%20Database">Manipulating the Database</a>.
+<code>utmp.h</code> (SVID):  <a href="#Manipulating the Database">Manipulating the Database</a>.
 
 <br><dt><code>int utmpxname (const char *<var>file</var>)</code>
 <dd>
-<code>utmpx.h</code> (XPG4.2):  <a href="#XPG%20Functions">XPG Functions</a>.
+<code>utmpx.h</code> (XPG4.2):  <a href="#XPG Functions">XPG Functions</a>.
 
 <br><dt><code>va_alist</code>
 <dd>
-<code>varargs.h</code> (Unix):  <a href="#Old%20Varargs">Old Varargs</a>.
+<code>varargs.h</code> (Unix):  <a href="#Old Varargs">Old Varargs</a>.
 
 <br><dt><code><var>type</var> va_arg (va_list <var>ap</var>, <var>type</var>)</code>
 <dd>
-<code>stdarg.h</code> (ISO):  <a href="#Argument%20Macros">Argument Macros</a>.
+<code>stdarg.h</code> (ISO):  <a href="#Argument Macros">Argument Macros</a>.
 
 <br><dt><code>void __va_copy (va_list <var>dest</var>, va_list <var>src</var>)</code>
 <dd>
-<code>stdarg.h</code> (GNU):  <a href="#Argument%20Macros">Argument Macros</a>.
+<code>stdarg.h</code> (GNU):  <a href="#Argument Macros">Argument Macros</a>.
 
 <br><dt><code>va_dcl</code>
 <dd>
-<code>varargs.h</code> (Unix):  <a href="#Old%20Varargs">Old Varargs</a>.
+<code>varargs.h</code> (Unix):  <a href="#Old Varargs">Old Varargs</a>.
 
 <br><dt><code>void va_end (va_list <var>ap</var>)</code>
 <dd>
-<code>stdarg.h</code> (ISO):  <a href="#Argument%20Macros">Argument Macros</a>.
+<code>stdarg.h</code> (ISO):  <a href="#Argument Macros">Argument Macros</a>.
 
 <br><dt><code>va_list</code>
 <dd>
-<code>stdarg.h</code> (ISO):  <a href="#Argument%20Macros">Argument Macros</a>.
+<code>stdarg.h</code> (ISO):  <a href="#Argument Macros">Argument Macros</a>.
 
 <br><dt><code>void * valloc (size_t <var>size</var>)</code>
 <dd>
-<code>malloc.h</code>, <code>stdlib.h</code> (BSD):  <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>.
+<code>malloc.h</code>, <code>stdlib.h</code> (BSD):  <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>.
 
 <br><dt><code>int vasprintf (char **<var>ptr</var>, const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>void va_start (va_list <var>ap</var>)</code>
 <dd>
-<code>varargs.h</code> (Unix):  <a href="#Old%20Varargs">Old Varargs</a>.
+<code>varargs.h</code> (Unix):  <a href="#Old Varargs">Old Varargs</a>.
 
 <br><dt><code>void va_start (va_list <var>ap</var>, <var>last-required</var>)</code>
 <dd>
-<code>stdarg.h</code> (ISO):  <a href="#Argument%20Macros">Argument Macros</a>.
+<code>stdarg.h</code> (ISO):  <a href="#Argument Macros">Argument Macros</a>.
 
 <br><dt><code>int VDISCARD</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Other%20Special">Other Special</a>.
+<code>termios.h</code> (BSD):  <a href="#Other Special">Other Special</a>.
 
 <br><dt><code>int VDSUSP</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Signal%20Characters">Signal Characters</a>.
+<code>termios.h</code> (BSD):  <a href="#Signal Characters">Signal Characters</a>.
 
 <br><dt><code>int VEOF</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Editing%20Characters">Editing Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Editing Characters">Editing Characters</a>.
 
 <br><dt><code>int VEOL</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Editing%20Characters">Editing Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Editing Characters">Editing Characters</a>.
 
 <br><dt><code>int VEOL2</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Editing%20Characters">Editing Characters</a>.
+<code>termios.h</code> (BSD):  <a href="#Editing Characters">Editing Characters</a>.
 
 <br><dt><code>int VERASE</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Editing%20Characters">Editing Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Editing Characters">Editing Characters</a>.
 
 <br><dt><code>void verr (int <var>status</var>, const char *<var>format</var>, va_list)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>void verrx (int <var>status</var>, const char *<var>format</var>, va_list)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>int versionsort (const void *<var>a</var>, const void *<var>b</var>)</code>
 <dd>
-<code>dirent.h</code> (GNU):  <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>.
+<code>dirent.h</code> (GNU):  <a href="#Scanning Directory Content">Scanning Directory Content</a>.
 
 <br><dt><code>int versionsort64 (const void *<var>a</var>, const void *<var>b</var>)</code>
 <dd>
-<code>dirent.h</code> (GNU):  <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>.
+<code>dirent.h</code> (GNU):  <a href="#Scanning Directory Content">Scanning Directory Content</a>.
 
 <br><dt><code>pid_t vfork (void)</code>
 <dd>
-<code>unistd.h</code> (BSD):  <a href="#Creating%20a%20Process">Creating a Process</a>.
+<code>unistd.h</code> (BSD):  <a href="#Creating a Process">Creating a Process</a>.
 
 <br><dt><code>int vfprintf (FILE *<var>stream</var>, const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int vfscanf (FILE *<var>stream</var>, const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Variable Arguments Input">Variable Arguments Input</a>.
 
 <br><dt><code>int vfwprintf (FILE *<var>stream</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>wchar.h</code> (ISO):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int vfwscanf (FILE *<var>stream</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>.
+<code>wchar.h</code> (ISO):  <a href="#Variable Arguments Input">Variable Arguments Input</a>.
 
 <br><dt><code>int VINTR</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Signal%20Characters">Signal Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Signal Characters">Signal Characters</a>.
 
 <br><dt><code>int VKILL</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Editing%20Characters">Editing Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Editing Characters">Editing Characters</a>.
 
 <br><dt><code>int vlimit (int <var>resource</var>, int <var>limit</var>)</code>
 <dd>
-<code>sys/vlimit.h</code> (BSD):  <a href="#Limits%20on%20Resources">Limits on Resources</a>.
+<code>sys/vlimit.h</code> (BSD):  <a href="#Limits on Resources">Limits on Resources</a>.
 
 <br><dt><code>int VLNEXT</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Other%20Special">Other Special</a>.
+<code>termios.h</code> (BSD):  <a href="#Other Special">Other Special</a>.
 
 <br><dt><code>int VMIN</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Noncanonical%20Input">Noncanonical Input</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Noncanonical Input">Noncanonical Input</a>.
 
 <br><dt><code>int vprintf (const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int VQUIT</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Signal%20Characters">Signal Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Signal Characters">Signal Characters</a>.
 
 <br><dt><code>int VREPRINT</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Editing%20Characters">Editing Characters</a>.
+<code>termios.h</code> (BSD):  <a href="#Editing Characters">Editing Characters</a>.
 
 <br><dt><code>int vscanf (const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Variable Arguments Input">Variable Arguments Input</a>.
 
 <br><dt><code>int vsnprintf (char *<var>s</var>, size_t <var>size</var>, const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (GNU):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>stdio.h</code> (GNU):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int vsprintf (char *<var>s</var>, const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>stdio.h</code> (ISO):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int vsscanf (const char *<var>s</var>, const char *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>stdio.h</code> (ISO):  <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>.
+<code>stdio.h</code> (ISO):  <a href="#Variable Arguments Input">Variable Arguments Input</a>.
 
 <br><dt><code>int VSTART</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Start%2fStop Characters">Start/Stop Characters</a>.
 
 <br><dt><code>int VSTATUS</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Other%20Special">Other Special</a>.
+<code>termios.h</code> (BSD):  <a href="#Other Special">Other Special</a>.
 
 <br><dt><code>int VSTOP</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Start%2fStop Characters">Start/Stop Characters</a>.
 
 <br><dt><code>int VSUSP</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Signal%20Characters">Signal Characters</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Signal Characters">Signal Characters</a>.
 
 <br><dt><code>int vswprintf (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>wchar.h</code> (GNU):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int vswscanf (const wchar_t *<var>s</var>, const wchar_t *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>.
+<code>wchar.h</code> (ISO):  <a href="#Variable Arguments Input">Variable Arguments Input</a>.
 
 <br><dt><code>void vsyslog (int <var>facility_priority</var>, char *<var>format</var>, va_list arglist)</code>
 <dd>
-<code>syslog.h</code> (BSD):  <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>.
+<code>syslog.h</code> (BSD):  <a href="#syslog%3b vsyslog">syslog; vsyslog</a>.
 
 <br><dt><code>int VTIME</code>
 <dd>
-<code>termios.h</code> (POSIX.1):  <a href="#Noncanonical%20Input">Noncanonical Input</a>.
+<code>termios.h</code> (POSIX.1):  <a href="#Noncanonical Input">Noncanonical Input</a>.
 
 <br><dt><code>int vtimes (struct vtimes <var>current</var>, struct vtimes <var>child</var>)</code>
 <dd>
-<code>vtimes.h</code> (vtimes.h):  <a href="#Resource%20Usage">Resource Usage</a>.
+<code>vtimes.h</code> (vtimes.h):  <a href="#Resource Usage">Resource Usage</a>.
 
 <br><dt><code>void vwarn (const char *<var>format</var>, va_list)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>void vwarnx (const char *<var>format</var>, va_list)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>int VWERASE</code>
 <dd>
-<code>termios.h</code> (BSD):  <a href="#Editing%20Characters">Editing Characters</a>.
+<code>termios.h</code> (BSD):  <a href="#Editing Characters">Editing Characters</a>.
 
 <br><dt><code>int vwprintf (const wchar_t *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>.
+<code>wchar.h</code> (ISO):  <a href="#Variable Arguments Output">Variable Arguments Output</a>.
 
 <br><dt><code>int vwscanf (const wchar_t *<var>template</var>, va_list <var>ap</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>.
+<code>wchar.h</code> (ISO):  <a href="#Variable Arguments Input">Variable Arguments Input</a>.
 
 <br><dt><code>pid_t wait (int *<var>status-ptr</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion">Process Completion</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion">Process Completion</a>.
 
 <br><dt><code>pid_t wait3 (union wait *<var>status-ptr</var>, int <var>options</var>, struct rusage *<var>usage</var>)</code>
 <dd>
-<code>sys/wait.h</code> (BSD):  <a href="#BSD%20Wait%20Functions">BSD Wait Functions</a>.
+<code>sys/wait.h</code> (BSD):  <a href="#BSD Wait Functions">BSD Wait Functions</a>.
 
 <br><dt><code>pid_t wait4 (pid_t <var>pid</var>, int *<var>status-ptr</var>, int <var>options</var>, struct rusage *<var>usage</var>)</code>
 <dd>
-<code>sys/wait.h</code> (BSD):  <a href="#Process%20Completion">Process Completion</a>.
+<code>sys/wait.h</code> (BSD):  <a href="#Process Completion">Process Completion</a>.
 
 <br><dt><code>pid_t waitpid (pid_t <var>pid</var>, int *<var>status-ptr</var>, int <var>options</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion">Process Completion</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion">Process Completion</a>.
 
 <br><dt><code>void warn (const char *<var>format</var>, <small>...</small>)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>void warnx (const char *<var>format</var>, <small>...</small>)</code>
 <dd>
-<code>err.h</code> (BSD):  <a href="#Error%20Messages">Error Messages</a>.
+<code>err.h</code> (BSD):  <a href="#Error Messages">Error Messages</a>.
 
 <br><dt><code>WCHAR_MAX</code>
 <dd>
-<code>limits.h</code> (GNU):  <a href="#Range%20of%20Type">Range of Type</a>.
+<code>limits.h</code> (GNU):  <a href="#Range of Type">Range of Type</a>.
 
 <br><dt><code>wint_t WCHAR_MAX</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Extended%20Char%20Intro">Extended Char Intro</a>.
+<code>wchar.h</code> (ISO):  <a href="#Extended Char Intro">Extended Char Intro</a>.
 
 <br><dt><code>wint_t WCHAR_MIN</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Extended%20Char%20Intro">Extended Char Intro</a>.
+<code>wchar.h</code> (ISO):  <a href="#Extended Char Intro">Extended Char Intro</a>.
 
 <br><dt><code>wchar_t</code>
 <dd>
-<code>stddef.h</code> (ISO):  <a href="#Extended%20Char%20Intro">Extended Char Intro</a>.
+<code>stddef.h</code> (ISO):  <a href="#Extended Char Intro">Extended Char Intro</a>.
 
 <br><dt><code>int WCOREDUMP (int <var>status</var>)</code>
 <dd>
-<code>sys/wait.h</code> (BSD):  <a href="#Process%20Completion%20Status">Process Completion Status</a>.
+<code>sys/wait.h</code> (BSD):  <a href="#Process Completion Status">Process Completion Status</a>.
 
 <br><dt><code>wchar_t * wcpcpy (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>wchar_t * wcpncpy (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>size_t wcrtomb (char *restrict <var>s</var>, wchar_t <var>wc</var>, mbstate_t *restrict <var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Converting%20a%20Character">Converting a Character</a>.
+<code>wchar.h</code> (ISO):  <a href="#Converting a Character">Converting a Character</a>.
 
 <br><dt><code>int wcscasecmp (const wchar_t *<var>ws1</var>, const wchar_T *<var>ws2</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>wchar.h</code> (GNU):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>wchar_t * wcscat (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>wchar_t * wcschr (const wchar_t *<var>wstring</var>, int <var>wc</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>wchar_t * wcschrnul (const wchar_t *<var>wstring</var>, wchar_t <var>wc</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (GNU):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>int wcscmp (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>wchar.h</code> (ISO):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>int wcscoll (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Collation%20Functions">Collation Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Collation Functions">Collation Functions</a>.
 
 <br><dt><code>wchar_t * wcscpy (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>size_t wcscspn (const wchar_t *<var>wstring</var>, const wchar_t *<var>stopset</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>wchar_t * wcsdup (const wchar_t *<var>ws</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>size_t wcsftime (wchar_t *<var>s</var>, size_t <var>size</var>, const wchar_t *<var>template</var>, const struct tm *<var>brokentime</var>)</code>
 <dd>
-<code>time.h</code> (ISO/Amend1):  <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>.
+<code>time.h</code> (ISO/Amend1):  <a href="#Formatting Calendar Time">Formatting Calendar Time</a>.
 
 <br><dt><code>size_t wcslen (const wchar_t *<var>ws</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#String%20Length">String Length</a>.
+<code>wchar.h</code> (ISO):  <a href="#String Length">String Length</a>.
 
 <br><dt><code>int wcsncasecmp (const wchar_t *<var>ws1</var>, const wchar_t *<var>s2</var>, size_t <var>n</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>wchar.h</code> (GNU):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>wchar_t * wcsncat (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>int wcsncmp (const wchar_t *<var>ws1</var>, const wchar_t *<var>ws2</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>wchar.h</code> (ISO):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>wchar_t * wcsncpy (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>size_t wcsnlen (const wchar_t *<var>ws</var>, size_t <var>maxlen</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#String%20Length">String Length</a>.
+<code>wchar.h</code> (GNU):  <a href="#String Length">String Length</a>.
 
 <br><dt><code>size_t wcsnrtombs (char *restrict <var>dst</var>, const wchar_t **restrict <var>src</var>, size_t <var>nwc</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Converting%20Strings">Converting Strings</a>.
+<code>wchar.h</code> (GNU):  <a href="#Converting Strings">Converting Strings</a>.
 
 <br><dt><code>wchar_t * wcspbrk (const wchar_t *<var>wstring</var>, const wchar_t *<var>stopset</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>wchar_t * wcsrchr (const wchar_t *<var>wstring</var>, wchar_t <var>c</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>size_t wcsrtombs (char *restrict <var>dst</var>, const wchar_t **restrict <var>src</var>, size_t <var>len</var>, mbstate_t *restrict <var>ps</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Converting%20Strings">Converting Strings</a>.
+<code>wchar.h</code> (ISO):  <a href="#Converting Strings">Converting Strings</a>.
 
 <br><dt><code>size_t wcsspn (const wchar_t *<var>wstring</var>, const wchar_t *<var>skipset</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>wchar_t * wcsstr (const wchar_t *<var>haystack</var>, const wchar_t *<var>needle</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>double wcstod (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Parsing%20of%20Floats">Parsing of Floats</a>.
+<code>wchar.h</code> (ISO):  <a href="#Parsing of Floats">Parsing of Floats</a>.
 
 <br><dt><code>float wcstof (const wchar_t *<var>string</var>, wchar_t **<var>tailptr</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Floats">Parsing of Floats</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Floats">Parsing of Floats</a>.
 
 <br><dt><code>intmax_t wcstoimax (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>wchar_t * wcstok (wchar_t *<var>newstring</var>, const char *<var>delimiters</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>.
+<code>wchar.h</code> (ISO):  <a href="#Finding Tokens in a String">Finding Tokens in a String</a>.
 
 <br><dt><code>long int wcstol (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>long double wcstold (const wchar_t *<var>string</var>, wchar_t **<var>tailptr</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Parsing%20of%20Floats">Parsing of Floats</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Parsing of Floats">Parsing of Floats</a>.
 
 <br><dt><code>long long int wcstoll (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>size_t wcstombs (char *<var>string</var>, const wchar_t *<var>wstring</var>, size_t <var>size</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>.
 
 <br><dt><code>long long int wcstoq (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (GNU):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>unsigned long int wcstoul (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>unsigned long long int wcstoull (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>uintmax_t wcstoumax (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (ISO):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>unsigned long long int wcstouq (const wchar_t *restrict <var>string</var>, wchar_t **restrict <var>tailptr</var>, int <var>base</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Parsing%20of%20Integers">Parsing of Integers</a>.
+<code>wchar.h</code> (GNU):  <a href="#Parsing of Integers">Parsing of Integers</a>.
 
 <br><dt><code>wchar_t * wcswcs (const wchar_t *<var>haystack</var>, const wchar_t *<var>needle</var>)</code>
 <dd>
-<code>wchar.h</code> (XPG):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (XPG):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>size_t wcsxfrm (wchar_t *restrict <var>wto</var>, const wchar_t *<var>wfrom</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Collation%20Functions">Collation Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Collation Functions">Collation Functions</a>.
 
 <br><dt><code>int wctob (wint_t <var>c</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Converting%20a%20Character">Converting a Character</a>.
+<code>wchar.h</code> (ISO):  <a href="#Converting a Character">Converting a Character</a>.
 
 <br><dt><code>int wctomb (char *<var>string</var>, wchar_t <var>wchar</var>)</code>
 <dd>
-<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>.
+<code>stdlib.h</code> (ISO):  <a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>.
 
 <br><dt><code>wctrans_t wctrans (const char *<var>property</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>.
+<code>wctype.h</code> (ISO):  <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>.
 
 <br><dt><code>wctrans_t</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>.
+<code>wctype.h</code> (ISO):  <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>.
 
 <br><dt><code>wctype_t wctype (const char *<var>property</var>)</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>wctype_t</code>
 <dd>
-<code>wctype.h</code> (ISO):  <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>.
+<code>wctype.h</code> (ISO):  <a href="#Classification of Wide Characters">Classification of Wide Characters</a>.
 
 <br><dt><code>int WEOF</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#EOF%20and%20Errors">EOF and Errors</a>.
+<code>wchar.h</code> (ISO):  <a href="#EOF and Errors">EOF and Errors</a>.
 
 <br><dt><code>wint_t WEOF</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Extended%20Char%20Intro">Extended Char Intro</a>.
+<code>wchar.h</code> (ISO):  <a href="#Extended Char Intro">Extended Char Intro</a>.
 
 <br><dt><code>int WEXITSTATUS (int <var>status</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion%20Status">Process Completion Status</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion Status">Process Completion Status</a>.
 
 <br><dt><code>int WIFEXITED (int <var>status</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion%20Status">Process Completion Status</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion Status">Process Completion Status</a>.
 
 <br><dt><code>int WIFSIGNALED (int <var>status</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion%20Status">Process Completion Status</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion Status">Process Completion Status</a>.
 
 <br><dt><code>int WIFSTOPPED (int <var>status</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion%20Status">Process Completion Status</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion Status">Process Completion Status</a>.
 
 <br><dt><code>wint_t</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Extended%20Char%20Intro">Extended Char Intro</a>.
+<code>wchar.h</code> (ISO):  <a href="#Extended Char Intro">Extended Char Intro</a>.
 
 <br><dt><code>wchar_t * wmemchr (const wchar_t *<var>block</var>, wchar_t <var>wc</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Search%20Functions">Search Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Search Functions">Search Functions</a>.
 
 <br><dt><code>int wmemcmp (const wchar_t *<var>a1</var>, const wchar_t *<var>a2</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wcjar.h</code> (ISO):  <a href="#String%2fArray%20Comparison">String/Array Comparison</a>.
+<code>wcjar.h</code> (ISO):  <a href="#String%2fArray Comparison">String/Array Comparison</a>.
 
 <br><dt><code>wchar_t * wmemcpy (wchar_t *restrict <var>wto</var>, const wchar_t *restruct <var>wfrom</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>wchar_t * wmemmove (wchar *<var>wto</var>, const wchar_t *<var>wfrom</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>wchar_t * wmempcpy (wchar_t *restrict <var>wto</var>, const wchar_t *restrict <var>wfrom</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (GNU):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (GNU):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>wchar_t * wmemset (wchar_t *<var>block</var>, wchar_t <var>wc</var>, size_t <var>size</var>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>.
+<code>wchar.h</code> (ISO):  <a href="#Copying and Concatenation">Copying and Concatenation</a>.
 
 <br><dt><code>int W_OK</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Testing%20File%20Access">Testing File Access</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Testing File Access">Testing File Access</a>.
 
 <br><dt><code>int wordexp (const char *<var>words</var>, wordexp_t *<var>word-vector-ptr</var>, int <var>flags</var>)</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>wordexp_t</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>void wordfree (wordexp_t *<var>word-vector-ptr</var>)</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>int wprintf (const wchar_t *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Formatted Output Functions">Formatted Output Functions</a>.
 
 <br><dt><code>WRDE_APPEND</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Flags for Wordexp">Flags for Wordexp</a>.
 
 <br><dt><code>WRDE_BADCHAR</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>WRDE_BADVAL</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>WRDE_CMDSUB</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>WRDE_DOOFFS</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Flags for Wordexp">Flags for Wordexp</a>.
 
 <br><dt><code>WRDE_NOCMD</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Flags for Wordexp">Flags for Wordexp</a>.
 
 <br><dt><code>WRDE_NOSPACE</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>WRDE_REUSE</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Flags for Wordexp">Flags for Wordexp</a>.
 
 <br><dt><code>WRDE_SHOWERR</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Flags for Wordexp">Flags for Wordexp</a>.
 
 <br><dt><code>WRDE_SYNTAX</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Calling%20Wordexp">Calling Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Calling Wordexp">Calling Wordexp</a>.
 
 <br><dt><code>WRDE_UNDEF</code>
 <dd>
-<code>wordexp.h</code> (POSIX.2):  <a href="#Flags%20for%20Wordexp">Flags for Wordexp</a>.
+<code>wordexp.h</code> (POSIX.2):  <a href="#Flags for Wordexp">Flags for Wordexp</a>.
 
 <br><dt><code>ssize_t write (int <var>filedes</var>, const void *<var>buffer</var>, size_t <var>size</var>)</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#I%2fO%20Primitives">I/O Primitives</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#I%2fO Primitives">I/O Primitives</a>.
 
 <br><dt><code>ssize_t writev (int <var>filedes</var>, const struct iovec *<var>vector</var>, int <var>count</var>)</code>
 <dd>
 <code>sys/uio.h</code> (BSD):  <a href="#Scatter-Gather">Scatter-Gather</a>.
 
 <br><dt><code>int wscanf (const wchar_t *<var>template</var>, <small>...</small>)</code>
 <dd>
-<code>wchar.h</code> (ISO):  <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>.
+<code>wchar.h</code> (ISO):  <a href="#Formatted Input Functions">Formatted Input Functions</a>.
 
 <br><dt><code>int WSTOPSIG (int <var>status</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion%20Status">Process Completion Status</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion Status">Process Completion Status</a>.
 
 <br><dt><code>int WTERMSIG (int <var>status</var>)</code>
 <dd>
-<code>sys/wait.h</code> (POSIX.1):  <a href="#Process%20Completion%20Status">Process Completion Status</a>.
+<code>sys/wait.h</code> (POSIX.1):  <a href="#Process Completion Status">Process Completion Status</a>.
 
 <br><dt><code>int X_OK</code>
 <dd>
-<code>unistd.h</code> (POSIX.1):  <a href="#Testing%20File%20Access">Testing File Access</a>.
+<code>unistd.h</code> (POSIX.1):  <a href="#Testing File Access">Testing File Access</a>.
 
 <br><dt><code>_XOPEN_SOURCE</code>
 <dd>
-(X/Open):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(X/Open):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>_XOPEN_SOURCE_EXTENDED</code>
 <dd>
-(X/Open):  <a href="#Feature%20Test%20Macros">Feature Test Macros</a>.
+(X/Open):  <a href="#Feature Test Macros">Feature Test Macros</a>.
 
 <br><dt><code>double y0 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float y0f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double y0l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>double y1 (double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float y1f (float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double y1l (long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>double yn (int n, double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>float ynf (int n, float <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 <br><dt><code>long double ynl (int n, long double <var>x</var>)</code>
 <dd>
-<code>math.h</code> (SVID):  <a href="#Special%20Functions">Special Functions</a>.
+<code>math.h</code> (SVID):  <a href="#Special Functions">Special Functions</a>.
 
 </dl>
 
 <p><hr>
 Node:<a name="Installation">Installation</a>,
 Next:<a rel=next accesskey=n href="#Maintenance">Maintenance</a>,
-Previous:<a rel=previous accesskey=p href="#Library%20Summary">Library Summary</a>,
+Previous:<a rel=previous accesskey=p href="#Library Summary">Library Summary</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Installing the GNU C Library</h2>
@@ -85860,22 +84251,22 @@
 change in the future.  Get it from the same place you got the main
 bundle; the file is <code>glibc-linuxthreads-<var>VERSION</var>.tar.gz</code>.
 
 <p>You will need recent versions of several GNU tools: definitely GCC and
-GNU Make, and possibly others.  See <a href="#Tools%20for%20Compilation">Tools for Compilation</a>, below.
+GNU Make, and possibly others.  See <a href="#Tools for Compilation">Tools for Compilation</a>, below.
 
 <ul>
-<li><a accesskey=1 href="#Configuring%20and%20compiling">Configuring and compiling</a>:    How to compile and test GNU libc. 
-<li><a accesskey=2 href="#Running%20make%20install">Running make install</a>:         How to install it once you've got it compiled. 
-<li><a accesskey=3 href="#Tools%20for%20Compilation">Tools for Compilation</a>:        You'll need these first. 
-<li><a accesskey=4 href="#Supported%20Configurations">Supported Configurations</a>:     What it runs on, what it doesn't. 
+<li><a accesskey=1 href="#Configuring and compiling">Configuring and compiling</a>:    How to compile and test GNU libc. 
+<li><a accesskey=2 href="#Running make install">Running make install</a>:         How to install it once you've got it compiled. 
+<li><a accesskey=3 href="#Tools for Compilation">Tools for Compilation</a>:        You'll need these first. 
+<li><a accesskey=4 href="#Supported Configurations">Supported Configurations</a>:     What it runs on, what it doesn't. 
 <li><a accesskey=5 href="#Linux">Linux</a>:                        Specific advice for Linux systems. 
-<li><a accesskey=6 href="#Reporting%20Bugs">Reporting Bugs</a>:               So they'll get fixed. 
+<li><a accesskey=6 href="#Reporting Bugs">Reporting Bugs</a>:               So they'll get fixed. 
 </ul>
 
 <p><hr>
-Node:<a name="Configuring%20and%20compiling">Configuring and compiling</a>,
-Next:<a rel=next accesskey=n href="#Running%20make%20install">Running make install</a>,
+Node:<a name="Configuring and compiling">Configuring and compiling</a>,
+Next:<a rel=next accesskey=n href="#Running make install">Running make install</a>,
 Up:<a rel=up accesskey=u href="#Installation">Installation</a>
 <br>
 
 <h3>Configuring and compiling GNU Libc</h3>
@@ -86037,9 +84428,9 @@
 
 <p>To build and run test programs which exercise some of the library
 facilities, type <code>make check</code>.  If it does not complete
 successfully, do not use the built library, and report a bug after
-verifying that the problem is not already known.  See <a href="#Reporting%20Bugs">Reporting Bugs</a>,
+verifying that the problem is not already known.  See <a href="#Reporting Bugs">Reporting Bugs</a>,
 for instructions on reporting bugs.  Note that some of the tests assume
 they are not being run by <code>root</code>.  We recommend you compile and
 test glibc as an unprivileged user.
 
@@ -86066,11 +84457,11 @@
 of <code>ar</code> and <code>ranlib</code> if the native tools are not configured to
 work with object files for the target you configured for.
 
 <p><hr>
-Node:<a name="Running%20make%20install">Running make install</a>,
-Next:<a rel=next accesskey=n href="#Tools%20for%20Compilation">Tools for Compilation</a>,
-Previous:<a rel=previous accesskey=p href="#Configuring%20and%20compiling">Configuring and compiling</a>,
+Node:<a name="Running make install">Running make install</a>,
+Next:<a rel=next accesskey=n href="#Tools for Compilation">Tools for Compilation</a>,
+Previous:<a rel=previous accesskey=p href="#Configuring and compiling">Configuring and compiling</a>,
 Up:<a rel=up accesskey=u href="#Installation">Installation</a>
 <br>
 
 <h3>Installing the C Library</h3>
@@ -86146,11 +84537,11 @@
 <code>/etc/localtime</code>.  For Germany, you might execute <code>ln -s
 /usr/share/zoneinfo/Europe/Berlin /etc/localtime</code>.
 
 <p><hr>
-Node:<a name="Tools%20for%20Compilation">Tools for Compilation</a>,
-Next:<a rel=next accesskey=n href="#Supported%20Configurations">Supported Configurations</a>,
-Previous:<a rel=previous accesskey=p href="#Running%20make%20install">Running make install</a>,
+Node:<a name="Tools for Compilation">Tools for Compilation</a>,
+Next:<a rel=next accesskey=n href="#Supported Configurations">Supported Configurations</a>,
+Previous:<a rel=previous accesskey=p href="#Running make install">Running make install</a>,
 Up:<a rel=up accesskey=u href="#Installation">Installation</a>
 <br>
 
 <h3>Recommended Tools for Compilation</h3>
@@ -86238,11 +84629,11 @@
 <p>You may also need these packages if you upgrade your source tree using
 patches, although we try to avoid this.
 
 <p><hr>
-Node:<a name="Supported%20Configurations">Supported Configurations</a>,
+Node:<a name="Supported Configurations">Supported Configurations</a>,
 Next:<a rel=next accesskey=n href="#Linux">Linux</a>,
-Previous:<a rel=previous accesskey=p href="#Tools%20for%20Compilation">Tools for Compilation</a>,
+Previous:<a rel=previous accesskey=p href="#Tools for Compilation">Tools for Compilation</a>,
 Up:<a rel=up accesskey=u href="#Installation">Installation</a>
 <br>
 
 <h3>Supported Configurations</h3>
@@ -86318,10 +84709,10 @@
 switches via <var>CFLAGS</var>.
 
 <p><hr>
 Node:<a name="Linux">Linux</a>,
-Next:<a rel=next accesskey=n href="#Reporting%20Bugs">Reporting Bugs</a>,
-Previous:<a rel=previous accesskey=p href="#Supported%20Configurations">Supported Configurations</a>,
+Next:<a rel=next accesskey=n href="#Reporting Bugs">Reporting Bugs</a>,
+Previous:<a rel=previous accesskey=p href="#Supported Configurations">Supported Configurations</a>,
 Up:<a rel=up accesskey=u href="#Installation">Installation</a>
 <br>
 
 <h3>Specific advice for Linux systems</h3>
@@ -86367,9 +84758,9 @@
 particularly hard, but you might have problems with any threaded
 program.
 
 <p><hr>
-Node:<a name="Reporting%20Bugs">Reporting Bugs</a>,
+Node:<a name="Reporting Bugs">Reporting Bugs</a>,
 Previous:<a rel=previous accesskey=p href="#Linux">Linux</a>,
 Up:<a rel=up accesskey=u href="#Installation">Installation</a>
 <br>
 
@@ -86397,9 +84788,9 @@
 Unix C libraries permit things that we don't, such as closing a file
 twice.
 
 <p>If you think you have found some way in which the GNU C library does not
-conform to the ISO and POSIX standards (see <a href="#Standards%20and%20Portability">Standards and Portability</a>), that is definitely a bug.  Report it!
+conform to the ISO and POSIX standards (see <a href="#Standards and Portability">Standards and Portability</a>), that is definitely a bug.  Report it!
 
 <p>Once you're sure you've found a bug, try to narrow it down to the
 smallest test case that reproduces the problem.  In the case of a C
 library, you really only need to narrow it down to one library
@@ -86433,16 +84824,16 @@
 
 <h2>Library Maintenance</h2>
 
 <ul>
-<li><a accesskey=1 href="#Source%20Layout">Source Layout</a>:          How to add new functions or header files
+<li><a accesskey=1 href="#Source Layout">Source Layout</a>:          How to add new functions or header files
                              to the GNU C library. 
 <li><a accesskey=2 href="#Porting">Porting</a>:                How to port the GNU C library to
                              a new machine or operating system. 
 </ul>
 
 <p><hr>
-Node:<a name="Source%20Layout">Source Layout</a>,
+Node:<a name="Source Layout">Source Layout</a>,
 Next:<a rel=next accesskey=n href="#Porting">Porting</a>,
 Up:<a rel=up accesskey=u href="#Maintenance">Maintenance</a>
 <br>
 
@@ -86539,9 +84930,9 @@
 </dl>
 
 <p><hr>
 Node:<a name="Porting">Porting</a>,
-Previous:<a rel=previous accesskey=p href="#Source%20Layout">Source Layout</a>,
+Previous:<a rel=previous accesskey=p href="#Source Layout">Source Layout</a>,
 Up:<a rel=up accesskey=u href="#Maintenance">Maintenance</a>
 <br>
 
 <h3>Porting the GNU C Library</h3>
@@ -86555,9 +84946,9 @@
 
 <p>All the machine-dependent and operating system-dependent files in the
 library are in the subdirectory <code>sysdeps</code> under the top-level
 library source directory.  This directory contains a hierarchy of
-subdirectories (see <a href="#Hierarchy%20Conventions">Hierarchy Conventions</a>).
+subdirectories (see <a href="#Hierarchy Conventions">Hierarchy Conventions</a>).
 
 <p>Each subdirectory of <code>sysdeps</code> contains source files for a
 particular machine or operating system, or for a class of machine or
 operating system (for example, systems by a particular vendor, or all
@@ -86600,9 +84991,9 @@
 the C library, then you should do so.  Otherwise, make them stubs.  A
 <dfn>stub</dfn> function is a function which cannot be implemented on a
 particular machine or operating system.  Stub functions always return an
 error, and set <code>errno</code> to <code>ENOSYS</code> (Function not implemented). 
-See <a href="#Error%20Reporting">Error Reporting</a>.  If you define a stub function, you must place
+See <a href="#Error Reporting">Error Reporting</a>.  If you define a stub function, you must place
 the statement <code>stub_warning(<var>function</var>)</code>, where <var>function</var>
 is the name of your function, after its definition; also, you must
 include the file <code>&lt;stub-tag.h&gt;</code> into your file.  This causes the
 function to be listed in the installed <code>&lt;gnu/stubs.h&gt;</code>, and
@@ -86708,16 +85099,16 @@
 
 <p>That is the general system for how system-dependencies are isolated.
 
 <ul>
-<li><a accesskey=1 href="#Hierarchy%20Conventions">Hierarchy Conventions</a>:        The layout of the <code>sysdeps</code> hierarchy. 
-<li><a accesskey=2 href="#Porting%20to%20Unix">Porting to Unix</a>:              Porting the library to an average
+<li><a accesskey=1 href="#Hierarchy Conventions">Hierarchy Conventions</a>:        The layout of the <code>sysdeps</code> hierarchy. 
+<li><a accesskey=2 href="#Porting to Unix">Porting to Unix</a>:              Porting the library to an average
                                    Unix-like system. 
 </ul>
 
 <p><hr>
-Node:<a name="Hierarchy%20Conventions">Hierarchy Conventions</a>,
-Next:<a rel=next accesskey=n href="#Porting%20to%20Unix">Porting to Unix</a>,
+Node:<a name="Hierarchy Conventions">Hierarchy Conventions</a>,
+Next:<a rel=next accesskey=n href="#Porting to Unix">Porting to Unix</a>,
 Up:<a rel=up accesskey=u href="#Porting">Porting</a>
 <br>
 
 <h4>Layout of the <code>sysdeps</code> Directory Hierarchy</h4>
@@ -86821,9 +85212,9 @@
 implemented in terms of itself, so a configuration using just
 <code>posix</code> cannot be complete.
 
 <br><dt><code>unix</code>
-<dd>This is the directory for Unix-like things.  See <a href="#Porting%20to%20Unix">Porting to Unix</a>. 
+<dd>This is the directory for Unix-like things.  See <a href="#Porting to Unix">Porting to Unix</a>. 
 <code>unix</code> implies <code>posix</code>.  There are some special-purpose
 subdirectories of <code>unix</code>:
 
 <dl>
@@ -86844,10 +85235,10 @@
 the <code>sysdeps</code> hierarchy, parallel to <code>unix</code> and <code>mach</code>. 
 </dl>
 
 <p><hr>
-Node:<a name="Porting%20to%20Unix">Porting to Unix</a>,
-Previous:<a rel=previous accesskey=p href="#Hierarchy%20Conventions">Hierarchy Conventions</a>,
+Node:<a name="Porting to Unix">Porting to Unix</a>,
+Previous:<a rel=previous accesskey=p href="#Hierarchy Conventions">Hierarchy Conventions</a>,
 Up:<a rel=up accesskey=u href="#Porting">Porting</a>
 <br>
 
 <h4>Porting the GNU C Library to Unix Systems</h4>
@@ -86888,9 +85279,9 @@
 <code>errlist.c</code> (for the <code>stdio</code> section of the library).
 
 <p><hr>
 Node:<a name="Contributors">Contributors</a>,
-Next:<a rel=next accesskey=n href="#Free%20Manuals">Free Manuals</a>,
+Next:<a rel=next accesskey=n href="#Free Manuals">Free Manuals</a>,
 Previous:<a rel=previous accesskey=p href="#Maintenance">Maintenance</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -87258,9 +85649,9 @@
 
 </ul>
 
 <p><hr>
-Node:<a name="Free%20Manuals">Free Manuals</a>,
+Node:<a name="Free Manuals">Free Manuals</a>,
 Next:<a rel=next accesskey=n href="#Copying">Copying</a>,
 Previous:<a rel=previous accesskey=p href="#Contributors">Contributors</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
@@ -87356,10 +85747,10 @@
 &lt;<code>http://www.fsf.org/doc/other-free-books.html</code>&gt;.
 
 <p><hr>
 Node:<a name="Copying">Copying</a>,
-Next:<a rel=next accesskey=n href="#Documentation%20License">Documentation License</a>,
-Previous:<a rel=previous accesskey=p href="#Free%20Manuals">Free Manuals</a>,
+Next:<a rel=next accesskey=n href="#Documentation License">Documentation License</a>,
+Previous:<a rel=previous accesskey=p href="#Free Manuals">Free Manuals</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>GNU Lesser General Public License</h2>
@@ -87862,19 +86253,19 @@
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary.  Here is a sample; alter the names:
 
 <br><pre>Yoyodyne, Inc., hereby disclaims all copyright interest in the library
-`Frob' (a library for tweaking knobs) written by James Random Hacker.
+'Frob' (a library for tweaking knobs) written by James Random Hacker.
 
 <var>signature of Ty Coon</var>, 1 April 1990
 Ty Coon, President of Vice
 </pre>
 
 <p>That's all there is to it!
 
 <p><hr>
-Node:<a name="Documentation%20License">Documentation License</a>,
-Next:<a rel=next accesskey=n href="#Concept%20Index">Concept Index</a>,
+Node:<a name="Documentation License">Documentation License</a>,
+Next:<a rel=next accesskey=n href="#Concept Index">Concept Index</a>,
 Previous:<a rel=previous accesskey=p href="#Copying">Copying</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
@@ -88228,10 +86619,10 @@
   under the terms of the GNU Free Documentation License, Version 1.1
   or any later version published by the Free Software Foundation;
   with the Invariant Sections being <var>list their titles</var>, with the
   Front-Cover Texts being <var>list</var>, and with the Back-Cover Texts being <var>list</var>.
-  A copy of the license is included in the section entitled ``GNU
-  Free Documentation License''.
+  A copy of the license is included in the section entitled "GNU
+  Free Documentation License".
 </pre>
 
 <p>If you have no Invariant Sections, write "with no Invariant Sections"
 instead of saying which ones are invariant.  If you have no
@@ -88243,3169 +86634,3169 @@
 free software license, such as the GNU General Public License,
 to permit their use in free software.
 
 <p><hr>
-Node:<a name="Concept%20Index">Concept Index</a>,
-Next:<a rel=next accesskey=n href="#Type%20Index">Type Index</a>,
-Previous:<a rel=previous accesskey=p href="#Documentation%20License">Documentation License</a>,
+Node:<a name="Concept Index">Concept Index</a>,
+Next:<a rel=next accesskey=n href="#Type Index">Type Index</a>,
+Previous:<a rel=previous accesskey=p href="#Documentation License">Documentation License</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Concept Index</h2>
 
 <ul compact>
-<li>/etc/hostname: <a href="#Host%20Identification">Host Identification</a>
-<li><code>/etc/nsswitch.conf</code>: <a href="#NSS%20Configuration%20File">NSS Configuration File</a>
-<li>4.<var>n</var> BSD Unix: <a href="#Berkeley%20Unix">Berkeley Unix</a>
-<li>__va_copy: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>_POSIX_OPTION_ORDER</code> environment variable.: <a href="#Standard%20Environment">Standard Environment</a>
-<li><code>_POSIX_SAVED_IDS</code>: <a href="#How%20Change%20Persona">How Change Persona</a>
-<li>abort signal: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li>aborting a program: <a href="#Aborting%20a%20Program">Aborting a Program</a>
-<li>absolute file name: <a href="#File%20Name%20Resolution">File Name Resolution</a>
-<li>absolute priority: <a href="#Absolute%20Priority">Absolute Priority</a>
-<li>absolute value functions: <a href="#Absolute%20Value">Absolute Value</a>
-<li>accepting connections: <a href="#Accepting%20Connections">Accepting Connections</a>
-<li>access permission for a file: <a href="#Access%20Permission">Access Permission</a>
-<li>access, testing for: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li>accessing directories: <a href="#Accessing%20Directories">Accessing Directories</a>
-<li>address of socket: <a href="#Socket%20Addresses">Socket Addresses</a>
-<li>address space: <a href="#Program%20Basics">Program Basics</a>, <a href="#Memory%20Subsystem">Memory Subsystem</a>
-<li>alarm signal: <a href="#Alarm%20Signals">Alarm Signals</a>
-<li>alarms, setting: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>alignment (in obstacks): <a href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>
-<li>alignment (with <code>malloc</code>): <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>
-<li><code>alloca</code> disadvantages: <a href="#Disadvantages%20of%20Alloca">Disadvantages of Alloca</a>
-<li><code>alloca</code> function: <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
+<li>/etc/hostname: <a href="#Host Identification">Host Identification</a>
+<li><code>/etc/nsswitch.conf</code>: <a href="#NSS Configuration File">NSS Configuration File</a>
+<li>4.<var>n</var> BSD Unix: <a href="#Berkeley Unix">Berkeley Unix</a>
+<li>__va_copy: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>_POSIX_OPTION_ORDER</code> environment variable.: <a href="#Standard Environment">Standard Environment</a>
+<li><code>_POSIX_SAVED_IDS</code>: <a href="#How Change Persona">How Change Persona</a>
+<li>abort signal: <a href="#Program Error Signals">Program Error Signals</a>
+<li>aborting a program: <a href="#Aborting a Program">Aborting a Program</a>
+<li>absolute file name: <a href="#File Name Resolution">File Name Resolution</a>
+<li>absolute priority: <a href="#Absolute Priority">Absolute Priority</a>
+<li>absolute value functions: <a href="#Absolute Value">Absolute Value</a>
+<li>accepting connections: <a href="#Accepting Connections">Accepting Connections</a>
+<li>access permission for a file: <a href="#Access Permission">Access Permission</a>
+<li>access, testing for: <a href="#Testing File Access">Testing File Access</a>
+<li>accessing directories: <a href="#Accessing Directories">Accessing Directories</a>
+<li>address of socket: <a href="#Socket Addresses">Socket Addresses</a>
+<li>address space: <a href="#Program Basics">Program Basics</a>, <a href="#Memory Subsystem">Memory Subsystem</a>
+<li>alarm signal: <a href="#Alarm Signals">Alarm Signals</a>
+<li>alarms, setting: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>alignment (in obstacks): <a href="#Obstacks Data Alignment">Obstacks Data Alignment</a>
+<li>alignment (with <code>malloc</code>): <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>
+<li><code>alloca</code> disadvantages: <a href="#Disadvantages of Alloca">Disadvantages of Alloca</a>
+<li><code>alloca</code> function: <a href="#Variable Size Automatic">Variable Size Automatic</a>
 <li>allocating pseudo-terminals: <a href="#Allocation">Allocation</a>
-<li>allocation (obstacks): <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>
-<li>allocation debugging: <a href="#Allocation%20Debugging">Allocation Debugging</a>
-<li>allocation hooks, for <code>malloc</code>: <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>
-<li>allocation of memory with <code>malloc</code>: <a href="#Basic%20Allocation">Basic Allocation</a>
-<li>allocation size of string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>allocation statistics: <a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>
-<li>alphabetic character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>alphanumeric character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>append-access files: <a href="#File%20Position">File Position</a>
-<li>argc (program argument count): <a href="#Program%20Arguments">Program Arguments</a>
+<li>allocation (obstacks): <a href="#Allocation in an Obstack">Allocation in an Obstack</a>
+<li>allocation debugging: <a href="#Allocation Debugging">Allocation Debugging</a>
+<li>allocation hooks, for <code>malloc</code>: <a href="#Hooks for Malloc">Hooks for Malloc</a>
+<li>allocation of memory with <code>malloc</code>: <a href="#Basic Allocation">Basic Allocation</a>
+<li>allocation size of string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>allocation statistics: <a href="#Statistics of Malloc">Statistics of Malloc</a>
+<li>alphabetic character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>alphanumeric character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>append-access files: <a href="#File Position">File Position</a>
+<li>argc (program argument count): <a href="#Program Arguments">Program Arguments</a>
 <li>argp (program argument parser): <a href="#Argp">Argp</a>
-<li>argp parser functions: <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>
-<li>ARGP_HELP_FMT environment variable: <a href="#Argp%20User%20Customization">Argp User Customization</a>
+<li>argp parser functions: <a href="#Argp Parser Functions">Argp Parser Functions</a>
+<li>ARGP_HELP_FMT environment variable: <a href="#Argp User Customization">Argp User Customization</a>
 <li>argument parsing with argp: <a href="#Argp">Argp</a>
-<li>argument promotion: <a href="#Calling%20Variadics">Calling Variadics</a>
-<li>argument vectors, null-character separated: <a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
-<li>arguments (variadic functions): <a href="#Receiving%20Arguments">Receiving Arguments</a>
-<li>arguments, how many: <a href="#How%20Many%20Arguments">How Many Arguments</a>
-<li>arguments, to program: <a href="#Program%20Arguments">Program Arguments</a>
-<li>argv (program argument vector): <a href="#Program%20Arguments">Program Arguments</a>
-<li>argz vectors (string vectors): <a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
-<li>arithmetic expansion: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>array comparison functions: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li>array copy functions: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li>array search function: <a href="#Array%20Search%20Function">Array Search Function</a>
-<li>array sort function: <a href="#Array%20Sort%20Function">Array Sort Function</a>
-<li>ASCII character: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>assertions: <a href="#Consistency%20Checking">Consistency Checking</a>
-<li>attributes of a file: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li>automatic freeing: <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
-<li>automatic memory allocation: <a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>
-<li>automatic storage class: <a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>
-<li>automatic storage with variable size: <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
-<li>background job: <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>
-<li>background job, launching: <a href="#Foreground%20and%20Background">Foreground and Background</a>
+<li>argument promotion: <a href="#Calling Variadics">Calling Variadics</a>
+<li>argument vectors, null-character separated: <a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
+<li>arguments (variadic functions): <a href="#Receiving Arguments">Receiving Arguments</a>
+<li>arguments, how many: <a href="#How Many Arguments">How Many Arguments</a>
+<li>arguments, to program: <a href="#Program Arguments">Program Arguments</a>
+<li>argv (program argument vector): <a href="#Program Arguments">Program Arguments</a>
+<li>argz vectors (string vectors): <a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
+<li>arithmetic expansion: <a href="#Expansion Stages">Expansion Stages</a>
+<li>array comparison functions: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li>array copy functions: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li>array search function: <a href="#Array Search Function">Array Search Function</a>
+<li>array sort function: <a href="#Array Sort Function">Array Sort Function</a>
+<li>ASCII character: <a href="#Classification of Characters">Classification of Characters</a>
+<li>assertions: <a href="#Consistency Checking">Consistency Checking</a>
+<li>attributes of a file: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li>automatic freeing: <a href="#Variable Size Automatic">Variable Size Automatic</a>
+<li>automatic memory allocation: <a href="#Memory Allocation and C">Memory Allocation and C</a>
+<li>automatic storage class: <a href="#Memory Allocation and C">Memory Allocation and C</a>
+<li>automatic storage with variable size: <a href="#Variable Size Automatic">Variable Size Automatic</a>
+<li>background job: <a href="#Concepts of Job Control">Concepts of Job Control</a>
+<li>background job, launching: <a href="#Foreground and Background">Foreground and Background</a>
 <li>backtrace: <a href="#Backtraces">Backtraces</a>
 <li>backtrace_fd: <a href="#Backtraces">Backtraces</a>
 <li>backtrace_symbols: <a href="#Backtraces">Backtraces</a>
-<li>base (of floating point number): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>baud rate: <a href="#Line%20Speed">Line Speed</a>
-<li>Berkeley Unix: <a href="#Berkeley%20Unix">Berkeley Unix</a>
-<li>Bessel functions: <a href="#Special%20Functions">Special Functions</a>
-<li>bias (of floating point number exponent): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>big-endian: <a href="#Byte%20Order">Byte Order</a>
-<li>binary I/O to a stream: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li>binary search function (for arrays): <a href="#Array%20Search%20Function">Array Search Function</a>
-<li>binary stream: <a href="#Binary%20Streams">Binary Streams</a>
-<li>binding a socket address: <a href="#Socket%20Addresses">Socket Addresses</a>
-<li>blank character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>block I/O to a stream: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li>blocked signals: <a href="#Delivery%20of%20Signal">Delivery of Signal</a>
-<li>blocked signals, checking for: <a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>
-<li>blocking signals: <a href="#Blocking%20Signals">Blocking Signals</a>
-<li>blocking signals, in a handler: <a href="#Blocking%20for%20Handler">Blocking for Handler</a>
-<li>bootstrapping, and services: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li>break condition, detecting: <a href="#Input%20Modes">Input Modes</a>
-<li>break condition, generating: <a href="#Line%20Control">Line Control</a>
-<li>breaking a string into tokens: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li>broken pipe signal: <a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li>broken-down time: <a href="#Broken-down%20Time">Broken-down Time</a>, <a href="#Calendar%20Time">Calendar Time</a>
-<li>BSD compatibility library: <a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li>BSD compatibility library.: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li>BSD Unix: <a href="#Berkeley%20Unix">Berkeley Unix</a>
-<li>buffering of streams: <a href="#Stream%20Buffering">Stream Buffering</a>
-<li>buffering, controlling: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li>bugs, reporting: <a href="#Reporting%20Bugs">Reporting Bugs</a>
-<li>bus error: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li>butterfly: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li>byte order conversion, for socket: <a href="#Byte%20Order">Byte Order</a>
-<li>byte stream: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>C++ streams: <a href="#Streams%20and%20I18N">Streams and I18N</a>
-<li>calendar time: <a href="#Time%20Basics">Time Basics</a>
-<li>calendar time and broken-down time: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li>calendar, Gregorian: <a href="#Calendar%20Time">Calendar Time</a>
-<li>calling variadic functions: <a href="#Calling%20Variadics">Calling Variadics</a>
-<li>canonical input processing: <a href="#Canonical%20or%20Not">Canonical or Not</a>
-<li>capacity limits, POSIX: <a href="#General%20Limits">General Limits</a>
-<li>carrier detect: <a href="#Control%20Modes">Control Modes</a>
-<li>case conversion of characters: <a href="#Case%20Conversion">Case Conversion</a>
-<li>catching signals: <a href="#Delivery%20of%20Signal">Delivery of Signal</a>
-<li>categories for locales: <a href="#Locale%20Categories">Locale Categories</a>
-<li>change working directory: <a href="#Working%20Directory">Working Directory</a>
-<li>changing the locale: <a href="#Setting%20the%20Locale">Setting the Locale</a>
-<li>changing the size of a block (<code>malloc</code>): <a href="#Changing%20Block%20Size">Changing Block Size</a>
-<li>changing the size of a block (obstacks): <a href="#Growing%20Objects">Growing Objects</a>
-<li>channels: <a href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>
-<li>character case conversion: <a href="#Case%20Conversion">Case Conversion</a>
-<li>character predicates: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>character testing: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>checking for pending signals: <a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>
-<li>child process: <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>, <a href="#Processes">Processes</a>, <a href="#Processor%20Time">Processor Time</a>
-<li>child process signal: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li>chunks: <a href="#Obstack%20Chunks">Obstack Chunks</a>
-<li>classes, floating-point: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li>classification of characters: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>cleaning up a stream: <a href="#Linked%20Channels">Linked Channels</a>
-<li>clearing terminal input queue: <a href="#Line%20Control">Line Control</a>
+<li>base (of floating point number): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>baud rate: <a href="#Line Speed">Line Speed</a>
+<li>Berkeley Unix: <a href="#Berkeley Unix">Berkeley Unix</a>
+<li>Bessel functions: <a href="#Special Functions">Special Functions</a>
+<li>bias (of floating point number exponent): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>big-endian: <a href="#Byte Order">Byte Order</a>
+<li>binary I/O to a stream: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li>binary search function (for arrays): <a href="#Array Search Function">Array Search Function</a>
+<li>binary stream: <a href="#Binary Streams">Binary Streams</a>
+<li>binding a socket address: <a href="#Socket Addresses">Socket Addresses</a>
+<li>blank character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>block I/O to a stream: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li>blocked signals: <a href="#Delivery of Signal">Delivery of Signal</a>
+<li>blocked signals, checking for: <a href="#Checking for Pending Signals">Checking for Pending Signals</a>
+<li>blocking signals: <a href="#Blocking Signals">Blocking Signals</a>
+<li>blocking signals, in a handler: <a href="#Blocking for Handler">Blocking for Handler</a>
+<li>bootstrapping, and services: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li>break condition, detecting: <a href="#Input Modes">Input Modes</a>
+<li>break condition, generating: <a href="#Line Control">Line Control</a>
+<li>breaking a string into tokens: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li>broken pipe signal: <a href="#Operation Error Signals">Operation Error Signals</a>
+<li>broken-down time: <a href="#Broken-down Time">Broken-down Time</a>, <a href="#Calendar Time">Calendar Time</a>
+<li>BSD compatibility library: <a href="#Process Group Functions">Process Group Functions</a>
+<li>BSD compatibility library.: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li>BSD Unix: <a href="#Berkeley Unix">Berkeley Unix</a>
+<li>buffering of streams: <a href="#Stream Buffering">Stream Buffering</a>
+<li>buffering, controlling: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li>bugs, reporting: <a href="#Reporting Bugs">Reporting Bugs</a>
+<li>bus error: <a href="#Program Error Signals">Program Error Signals</a>
+<li>butterfly: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li>byte order conversion, for socket: <a href="#Byte Order">Byte Order</a>
+<li>byte stream: <a href="#Socket Concepts">Socket Concepts</a>
+<li>C++ streams: <a href="#Streams and I18N">Streams and I18N</a>
+<li>calendar time: <a href="#Time Basics">Time Basics</a>
+<li>calendar time and broken-down time: <a href="#Broken-down Time">Broken-down Time</a>
+<li>calendar, Gregorian: <a href="#Calendar Time">Calendar Time</a>
+<li>calling variadic functions: <a href="#Calling Variadics">Calling Variadics</a>
+<li>canonical input processing: <a href="#Canonical or Not">Canonical or Not</a>
+<li>capacity limits, POSIX: <a href="#General Limits">General Limits</a>
+<li>carrier detect: <a href="#Control Modes">Control Modes</a>
+<li>case conversion of characters: <a href="#Case Conversion">Case Conversion</a>
+<li>catching signals: <a href="#Delivery of Signal">Delivery of Signal</a>
+<li>categories for locales: <a href="#Locale Categories">Locale Categories</a>
+<li>change working directory: <a href="#Working Directory">Working Directory</a>
+<li>changing the locale: <a href="#Setting the Locale">Setting the Locale</a>
+<li>changing the size of a block (<code>malloc</code>): <a href="#Changing Block Size">Changing Block Size</a>
+<li>changing the size of a block (obstacks): <a href="#Growing Objects">Growing Objects</a>
+<li>channels: <a href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>
+<li>character case conversion: <a href="#Case Conversion">Case Conversion</a>
+<li>character predicates: <a href="#Classification of Characters">Classification of Characters</a>
+<li>character testing: <a href="#Classification of Characters">Classification of Characters</a>
+<li>checking for pending signals: <a href="#Checking for Pending Signals">Checking for Pending Signals</a>
+<li>child process: <a href="#Process Creation Concepts">Process Creation Concepts</a>, <a href="#Processes">Processes</a>, <a href="#Processor Time">Processor Time</a>
+<li>child process signal: <a href="#Job Control Signals">Job Control Signals</a>
+<li>chunks: <a href="#Obstack Chunks">Obstack Chunks</a>
+<li>classes, floating-point: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li>classification of characters: <a href="#Classification of Characters">Classification of Characters</a>
+<li>cleaning up a stream: <a href="#Linked Channels">Linked Channels</a>
+<li>clearing terminal input queue: <a href="#Line Control">Line Control</a>
 <li>client: <a href="#Connections">Connections</a>
-<li>clock ticks: <a href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>
-<li>clock, high accuracy: <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li>close-on-exec (file descriptor flag): <a href="#Descriptor%20Flags">Descriptor Flags</a>
-<li>closing a file descriptor: <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li>closing a socket: <a href="#Closing%20a%20Socket">Closing a Socket</a>
-<li>closing a stream: <a href="#Closing%20Streams">Closing Streams</a>
-<li>collating strings: <a href="#Collation%20Functions">Collation Functions</a>
-<li>combining locales: <a href="#Choosing%20Locale">Choosing Locale</a>
-<li>command argument syntax: <a href="#Argument%20Syntax">Argument Syntax</a>
-<li>command arguments, parsing: <a href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
-<li>command line arguments: <a href="#Program%20Arguments">Program Arguments</a>
-<li>command substitution: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>communication style (of a socket): <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>comparing strings and arrays: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li>Comparison Function: <a href="#Comparison%20Functions">Comparison Functions</a>
-<li>compiling: <a href="#Configuring%20and%20compiling">Configuring and compiling</a>
-<li>complex exponentiation functions: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li>complex logarithm functions: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li>complex numbers: <a href="#Complex%20Numbers">Complex Numbers</a>
-<li>complex trigonometric functions: <a href="#Trig%20Functions">Trig Functions</a>
-<li>concatenating strings: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li>configurations, all supported: <a href="#Supported%20Configurations">Supported Configurations</a>
-<li>configuring: <a href="#Configuring%20and%20compiling">Configuring and compiling</a>
-<li>conjugate complex numbers: <a href="#Operations%20on%20Complex">Operations on Complex</a>
+<li>clock ticks: <a href="#Processor And CPU Time">Processor And CPU Time</a>
+<li>clock, high accuracy: <a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li>close-on-exec (file descriptor flag): <a href="#Descriptor Flags">Descriptor Flags</a>
+<li>closing a file descriptor: <a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li>closing a socket: <a href="#Closing a Socket">Closing a Socket</a>
+<li>closing a stream: <a href="#Closing Streams">Closing Streams</a>
+<li>collating strings: <a href="#Collation Functions">Collation Functions</a>
+<li>combining locales: <a href="#Choosing Locale">Choosing Locale</a>
+<li>command argument syntax: <a href="#Argument Syntax">Argument Syntax</a>
+<li>command arguments, parsing: <a href="#Parsing Program Arguments">Parsing Program Arguments</a>
+<li>command line arguments: <a href="#Program Arguments">Program Arguments</a>
+<li>command substitution: <a href="#Expansion Stages">Expansion Stages</a>
+<li>communication style (of a socket): <a href="#Socket Concepts">Socket Concepts</a>
+<li>comparing strings and arrays: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li>Comparison Function: <a href="#Comparison Functions">Comparison Functions</a>
+<li>compiling: <a href="#Configuring and compiling">Configuring and compiling</a>
+<li>complex exponentiation functions: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li>complex logarithm functions: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li>complex numbers: <a href="#Complex Numbers">Complex Numbers</a>
+<li>complex trigonometric functions: <a href="#Trig Functions">Trig Functions</a>
+<li>concatenating strings: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li>configurations, all supported: <a href="#Supported Configurations">Supported Configurations</a>
+<li>configuring: <a href="#Configuring and compiling">Configuring and compiling</a>
+<li>conjugate complex numbers: <a href="#Operations on Complex">Operations on Complex</a>
 <li>connecting a socket: <a href="#Connecting">Connecting</a>
 <li>connection: <a href="#Connections">Connections</a>
-<li>consistency checking: <a href="#Consistency%20Checking">Consistency Checking</a>
-<li>consistency checking, of heap: <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>
-<li>constants: <a href="#Mathematical%20Constants">Mathematical Constants</a>, <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>continue signal: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li>control character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>control operations on files: <a href="#Control%20Operations">Control Operations</a>
-<li>controlling process: <a href="#Controlling%20Terminal">Controlling Terminal</a>
-<li>controlling terminal: <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>
-<li>controlling terminal, access to: <a href="#Access%20to%20the%20Terminal">Access to the Terminal</a>
-<li>controlling terminal, determining: <a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>
-<li>controlling terminal, setting: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>conversion specifications (<code>printf</code>): <a href="#Formatted%20Output%20Basics">Formatted Output Basics</a>
-<li>conversion specifications (<code>scanf</code>): <a href="#Formatted%20Input%20Basics">Formatted Input Basics</a>
-<li>converting byte order: <a href="#Byte%20Order">Byte Order</a>
-<li>converting case of characters: <a href="#Case%20Conversion">Case Conversion</a>
-<li>converting file descriptor to stream: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li>converting floats to integers: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li>converting group ID to group name: <a href="#Lookup%20Group">Lookup Group</a>
-<li>converting group name to group ID: <a href="#Lookup%20Group">Lookup Group</a>
-<li>converting host address to name: <a href="#Host%20Names">Host Names</a>
-<li>converting host name to address: <a href="#Host%20Names">Host Names</a>
-<li>converting network name to network number: <a href="#Networks%20Database">Networks Database</a>
-<li>converting network number to network name: <a href="#Networks%20Database">Networks Database</a>
-<li>converting port number to service name: <a href="#Services%20Database">Services Database</a>
-<li>converting service name to port number: <a href="#Services%20Database">Services Database</a>
-<li>converting string to collation order: <a href="#Collation%20Functions">Collation Functions</a>
-<li>converting strings to numbers: <a href="#Parsing%20of%20Numbers">Parsing of Numbers</a>
-<li>converting user ID to user name: <a href="#Lookup%20User">Lookup User</a>
-<li>converting user name to user ID: <a href="#Lookup%20User">Lookup User</a>
-<li>cookie, for custom stream: <a href="#Streams%20and%20Cookies">Streams and Cookies</a>
-<li>copy-on-write page fault: <a href="#Locked%20Memory%20Details">Locked Memory Details</a>
-<li>copying strings and arrays: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
+<li>consistency checking: <a href="#Consistency Checking">Consistency Checking</a>
+<li>consistency checking, of heap: <a href="#Heap Consistency Checking">Heap Consistency Checking</a>
+<li>constants: <a href="#Mathematical Constants">Mathematical Constants</a>, <a href="#Memory Concepts">Memory Concepts</a>
+<li>continue signal: <a href="#Job Control Signals">Job Control Signals</a>
+<li>control character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>control operations on files: <a href="#Control Operations">Control Operations</a>
+<li>controlling process: <a href="#Controlling Terminal">Controlling Terminal</a>
+<li>controlling terminal: <a href="#Concepts of Job Control">Concepts of Job Control</a>
+<li>controlling terminal, access to: <a href="#Access to the Terminal">Access to the Terminal</a>
+<li>controlling terminal, determining: <a href="#Identifying the Terminal">Identifying the Terminal</a>
+<li>controlling terminal, setting: <a href="#Open-time Flags">Open-time Flags</a>
+<li>conversion specifications (<code>printf</code>): <a href="#Formatted Output Basics">Formatted Output Basics</a>
+<li>conversion specifications (<code>scanf</code>): <a href="#Formatted Input Basics">Formatted Input Basics</a>
+<li>converting byte order: <a href="#Byte Order">Byte Order</a>
+<li>converting case of characters: <a href="#Case Conversion">Case Conversion</a>
+<li>converting file descriptor to stream: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li>converting floats to integers: <a href="#Rounding Functions">Rounding Functions</a>
+<li>converting group ID to group name: <a href="#Lookup Group">Lookup Group</a>
+<li>converting group name to group ID: <a href="#Lookup Group">Lookup Group</a>
+<li>converting host address to name: <a href="#Host Names">Host Names</a>
+<li>converting host name to address: <a href="#Host Names">Host Names</a>
+<li>converting network name to network number: <a href="#Networks Database">Networks Database</a>
+<li>converting network number to network name: <a href="#Networks Database">Networks Database</a>
+<li>converting port number to service name: <a href="#Services Database">Services Database</a>
+<li>converting service name to port number: <a href="#Services Database">Services Database</a>
+<li>converting string to collation order: <a href="#Collation Functions">Collation Functions</a>
+<li>converting strings to numbers: <a href="#Parsing of Numbers">Parsing of Numbers</a>
+<li>converting user ID to user name: <a href="#Lookup User">Lookup User</a>
+<li>converting user name to user ID: <a href="#Lookup User">Lookup User</a>
+<li>cookie, for custom stream: <a href="#Streams and Cookies">Streams and Cookies</a>
+<li>copy-on-write page fault: <a href="#Locked Memory Details">Locked Memory Details</a>
+<li>copying strings and arrays: <a href="#Copying and Concatenation">Copying and Concatenation</a>
 <li>cpu priority: <a href="#Priority">Priority</a>
-<li>CPU time: <a href="#Processor%20Time">Processor Time</a>, <a href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>, <a href="#Time%20Basics">Time Basics</a>
-<li>create on open (file status flag): <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>creating a directory: <a href="#Creating%20Directories">Creating Directories</a>
-<li>creating a FIFO special file: <a href="#FIFO%20Special%20Files">FIFO Special Files</a>
-<li>creating a pipe: <a href="#Creating%20a%20Pipe">Creating a Pipe</a>
-<li>creating a pipe to a subprocess: <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>
-<li>creating a process: <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>
-<li>creating a socket: <a href="#Creating%20a%20Socket">Creating a Socket</a>
-<li>creating a socket pair: <a href="#Socket%20Pairs">Socket Pairs</a>
-<li>creating special files: <a href="#Making%20Special%20Files">Making Special Files</a>
-<li>cube root function: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li>currency symbols: <a href="#Currency%20Symbol">Currency Symbol</a>
-<li>current limit: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li>current working directory: <a href="#Working%20Directory">Working Directory</a>
-<li>custom streams: <a href="#Custom%20Streams">Custom Streams</a>
-<li>customizing <code>printf</code>: <a href="#Customizing%20Printf">Customizing Printf</a>
-<li>data loss on sockets: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>databases: <a href="#Name%20Service%20Switch">Name Service Switch</a>
+<li>CPU time: <a href="#Processor Time">Processor Time</a>, <a href="#Processor And CPU Time">Processor And CPU Time</a>, <a href="#Time Basics">Time Basics</a>
+<li>create on open (file status flag): <a href="#Open-time Flags">Open-time Flags</a>
+<li>creating a directory: <a href="#Creating Directories">Creating Directories</a>
+<li>creating a FIFO special file: <a href="#FIFO Special Files">FIFO Special Files</a>
+<li>creating a pipe: <a href="#Creating a Pipe">Creating a Pipe</a>
+<li>creating a pipe to a subprocess: <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>
+<li>creating a process: <a href="#Process Creation Concepts">Process Creation Concepts</a>
+<li>creating a socket: <a href="#Creating a Socket">Creating a Socket</a>
+<li>creating a socket pair: <a href="#Socket Pairs">Socket Pairs</a>
+<li>creating special files: <a href="#Making Special Files">Making Special Files</a>
+<li>cube root function: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li>currency symbols: <a href="#Currency Symbol">Currency Symbol</a>
+<li>current limit: <a href="#Limits on Resources">Limits on Resources</a>
+<li>current working directory: <a href="#Working Directory">Working Directory</a>
+<li>custom streams: <a href="#Custom Streams">Custom Streams</a>
+<li>customizing <code>printf</code>: <a href="#Customizing Printf">Customizing Printf</a>
+<li>data loss on sockets: <a href="#Socket Concepts">Socket Concepts</a>
+<li>databases: <a href="#Name Service Switch">Name Service Switch</a>
 <li>datagram socket: <a href="#Datagrams">Datagrams</a>
-<li>datagrams, transmitting: <a href="#Sending%20Datagrams">Sending Datagrams</a>
-<li>date: <a href="#Time%20Basics">Time Basics</a>
-<li>Daylight Saving Time: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li>decimal digit character: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>decimal-point separator: <a href="#General%20Numeric">General Numeric</a>
-<li>declaration (compared to definition): <a href="#Header%20Files">Header Files</a>
-<li>declaring variadic functions: <a href="#Calling%20Variadics">Calling Variadics</a>
-<li>decompose complex numbers: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li>default action (for a signal): <a href="#Delivery%20of%20Signal">Delivery of Signal</a>
-<li>default action for a signal: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li>default argument promotions: <a href="#Calling%20Variadics">Calling Variadics</a>
-<li>default value, and NSS: <a href="#Notes%20on%20NSS%20Configuration%20File">Notes on NSS Configuration File</a>
-<li>defining new <code>printf</code> conversions: <a href="#Customizing%20Printf">Customizing Printf</a>
-<li>definition (compared to declaration): <a href="#Header%20Files">Header Files</a>
-<li>delayed suspend character: <a href="#Signal%20Characters">Signal Characters</a>
-<li>deleting a directory: <a href="#Deleting%20Files">Deleting Files</a>
-<li>deleting a file: <a href="#Deleting%20Files">Deleting Files</a>
-<li>delivery of signals: <a href="#Delivery%20of%20Signal">Delivery of Signal</a>
-<li>descriptors and streams: <a href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>
-<li>digit character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>directories, accessing: <a href="#Accessing%20Directories">Accessing Directories</a>
-<li>directories, creating: <a href="#Creating%20Directories">Creating Directories</a>
-<li>directories, deleting: <a href="#Deleting%20Files">Deleting Files</a>
+<li>datagrams, transmitting: <a href="#Sending Datagrams">Sending Datagrams</a>
+<li>date: <a href="#Time Basics">Time Basics</a>
+<li>Daylight Saving Time: <a href="#Broken-down Time">Broken-down Time</a>
+<li>decimal digit character: <a href="#Classification of Characters">Classification of Characters</a>
+<li>decimal-point separator: <a href="#General Numeric">General Numeric</a>
+<li>declaration (compared to definition): <a href="#Header Files">Header Files</a>
+<li>declaring variadic functions: <a href="#Calling Variadics">Calling Variadics</a>
+<li>decompose complex numbers: <a href="#Operations on Complex">Operations on Complex</a>
+<li>default action (for a signal): <a href="#Delivery of Signal">Delivery of Signal</a>
+<li>default action for a signal: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li>default argument promotions: <a href="#Calling Variadics">Calling Variadics</a>
+<li>default value, and NSS: <a href="#Notes on NSS Configuration File">Notes on NSS Configuration File</a>
+<li>defining new <code>printf</code> conversions: <a href="#Customizing Printf">Customizing Printf</a>
+<li>definition (compared to declaration): <a href="#Header Files">Header Files</a>
+<li>delayed suspend character: <a href="#Signal Characters">Signal Characters</a>
+<li>deleting a directory: <a href="#Deleting Files">Deleting Files</a>
+<li>deleting a file: <a href="#Deleting Files">Deleting Files</a>
+<li>delivery of signals: <a href="#Delivery of Signal">Delivery of Signal</a>
+<li>descriptors and streams: <a href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>
+<li>digit character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>directories, accessing: <a href="#Accessing Directories">Accessing Directories</a>
+<li>directories, creating: <a href="#Creating Directories">Creating Directories</a>
+<li>directories, deleting: <a href="#Deleting Files">Deleting Files</a>
 <li>directory: <a href="#Directories">Directories</a>
 <li>directory entry: <a href="#Directories">Directories</a>
-<li>directory hierarchy: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li>directory stream: <a href="#Accessing%20Directories">Accessing Directories</a>
-<li>disadvantages of <code>alloca</code>: <a href="#Disadvantages%20of%20Alloca">Disadvantages of Alloca</a>
-<li>DISCARD character: <a href="#Other%20Special">Other Special</a>
-<li>division by zero: <a href="#FP%20Exceptions">FP Exceptions</a>
-<li>DNS: <a href="#Host%20Identification">Host Identification</a>
-<li>DNS server unavailable: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li>domain (of socket): <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>domain error: <a href="#Math%20Error%20Reporting">Math Error Reporting</a>
-<li>domain name: <a href="#Host%20Identification">Host Identification</a>
-<li>Domain Name System: <a href="#Host%20Identification">Host Identification</a>
-<li>dot notation, for Internet addresses: <a href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>
-<li>DSUSP character: <a href="#Signal%20Characters">Signal Characters</a>
-<li>duplicating file descriptors: <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>
-<li>dynamic memory allocation: <a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>
-<li>EBCDIC: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>echo of terminal input: <a href="#Local%20Modes">Local Modes</a>
-<li>effective group ID: <a href="#Process%20Persona">Process Persona</a>
-<li>effective user ID: <a href="#Process%20Persona">Process Persona</a>
-<li>efficiency and <code>malloc</code>: <a href="#Efficiency%20and%20Malloc">Efficiency and Malloc</a>
-<li>efficiency and obstacks: <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>
-<li>efficiency of chunks: <a href="#Obstack%20Chunks">Obstack Chunks</a>
-<li>EINTR, and restarting interrupted primitives: <a href="#Interrupted%20Primitives">Interrupted Primitives</a>
-<li>elapsed time: <a href="#Elapsed%20Time">Elapsed Time</a>, <a href="#Time%20Basics">Time Basics</a>
-<li>encryption: <a href="#Trivial%20Encryption">Trivial Encryption</a>
-<li>end of file, on a stream: <a href="#EOF%20and%20Errors">EOF and Errors</a>
-<li>end-of-file, on a file descriptor: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li>environment: <a href="#Environment%20Variables">Environment Variables</a>
-<li>environment access: <a href="#Environment%20Access">Environment Access</a>
-<li>environment representation: <a href="#Environment%20Access">Environment Access</a>
-<li>environment variable: <a href="#Environment%20Variables">Environment Variables</a>
-<li>environment vectors, null-character separated: <a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
-<li>envz vectors (environment vectors): <a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
-<li>EOF character: <a href="#Editing%20Characters">Editing Characters</a>
-<li>EOL character: <a href="#Editing%20Characters">Editing Characters</a>
-<li>EOL2 character: <a href="#Editing%20Characters">Editing Characters</a>
-<li>epoch: <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>
-<li>ERASE character: <a href="#Editing%20Characters">Editing Characters</a>
-<li>errno: <a href="#System%20Calls">System Calls</a>
-<li>error codes: <a href="#Error%20Reporting">Error Reporting</a>
-<li>error messages, in argp: <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>
-<li>error reporting: <a href="#Error%20Reporting">Error Reporting</a>
-<li>errors, mathematical: <a href="#Math%20Error%20Reporting">Math Error Reporting</a>
-<li>establishing a handler: <a href="#Signal%20Actions">Signal Actions</a>
-<li>ethers: <a href="#NSS%20Basics">NSS Basics</a>
-<li>EUC: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>EUC-JP: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li>exception: <a href="#Program%20Error%20Signals">Program Error Signals</a>, <a href="#FP%20Exceptions">FP Exceptions</a>
-<li>exclusive lock: <a href="#File%20Locks">File Locks</a>
-<li><code>exec</code> functions: <a href="#Executing%20a%20File">Executing a File</a>
-<li>execing a program: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>executable: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>executing a file: <a href="#Executing%20a%20File">Executing a File</a>
-<li>exit status: <a href="#Exit%20Status">Exit Status</a>
-<li>exit status value: <a href="#Program%20Termination">Program Termination</a>
-<li>exiting a program: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>expansion of shell words: <a href="#Word%20Expansion">Word Expansion</a>
-<li>exponent (of floating point number): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>exponentiation functions: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li>extending <code>printf</code>: <a href="#Customizing%20Printf">Customizing Printf</a>
-<li>extracting file descriptor from stream: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><code>fcntl</code> function: <a href="#Control%20Operations">Control Operations</a>
-<li>FDL, GNU Free Documentation License: <a href="#Documentation%20License">Documentation License</a>
-<li>feature test macros: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li>field splitting: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>FIFO special file: <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>
-<li>file access permission: <a href="#Access%20Permission">Access Permission</a>
-<li>file access time: <a href="#File%20Times">File Times</a>
-<li>file attribute modification time: <a href="#File%20Times">File Times</a>
-<li>file attributes: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li>file creation mask: <a href="#Setting%20Permissions">Setting Permissions</a>
-<li>file descriptor flags: <a href="#Descriptor%20Flags">Descriptor Flags</a>
-<li>file descriptor sets, for <code>select</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li>file descriptors, standard: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li>file locks: <a href="#File%20Locks">File Locks</a>
-<li>file modification time: <a href="#File%20Times">File Times</a>
-<li>file name: <a href="#File%20Names">File Names</a>
+<li>directory hierarchy: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li>directory stream: <a href="#Accessing Directories">Accessing Directories</a>
+<li>disadvantages of <code>alloca</code>: <a href="#Disadvantages of Alloca">Disadvantages of Alloca</a>
+<li>DISCARD character: <a href="#Other Special">Other Special</a>
+<li>division by zero: <a href="#FP Exceptions">FP Exceptions</a>
+<li>DNS: <a href="#Host Identification">Host Identification</a>
+<li>DNS server unavailable: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li>domain (of socket): <a href="#Socket Concepts">Socket Concepts</a>
+<li>domain error: <a href="#Math Error Reporting">Math Error Reporting</a>
+<li>domain name: <a href="#Host Identification">Host Identification</a>
+<li>Domain Name System: <a href="#Host Identification">Host Identification</a>
+<li>dot notation, for Internet addresses: <a href="#Abstract Host Addresses">Abstract Host Addresses</a>
+<li>DSUSP character: <a href="#Signal Characters">Signal Characters</a>
+<li>duplicating file descriptors: <a href="#Duplicating Descriptors">Duplicating Descriptors</a>
+<li>dynamic memory allocation: <a href="#Memory Allocation and C">Memory Allocation and C</a>
+<li>EBCDIC: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>echo of terminal input: <a href="#Local Modes">Local Modes</a>
+<li>effective group ID: <a href="#Process Persona">Process Persona</a>
+<li>effective user ID: <a href="#Process Persona">Process Persona</a>
+<li>efficiency and <code>malloc</code>: <a href="#Efficiency and Malloc">Efficiency and Malloc</a>
+<li>efficiency and obstacks: <a href="#Extra Fast Growing">Extra Fast Growing</a>
+<li>efficiency of chunks: <a href="#Obstack Chunks">Obstack Chunks</a>
+<li>EINTR, and restarting interrupted primitives: <a href="#Interrupted Primitives">Interrupted Primitives</a>
+<li>elapsed time: <a href="#Elapsed Time">Elapsed Time</a>, <a href="#Time Basics">Time Basics</a>
+<li>encryption: <a href="#Trivial Encryption">Trivial Encryption</a>
+<li>end of file, on a stream: <a href="#EOF and Errors">EOF and Errors</a>
+<li>end-of-file, on a file descriptor: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li>environment: <a href="#Environment Variables">Environment Variables</a>
+<li>environment access: <a href="#Environment Access">Environment Access</a>
+<li>environment representation: <a href="#Environment Access">Environment Access</a>
+<li>environment variable: <a href="#Environment Variables">Environment Variables</a>
+<li>environment vectors, null-character separated: <a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
+<li>envz vectors (environment vectors): <a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
+<li>EOF character: <a href="#Editing Characters">Editing Characters</a>
+<li>EOL character: <a href="#Editing Characters">Editing Characters</a>
+<li>EOL2 character: <a href="#Editing Characters">Editing Characters</a>
+<li>epoch: <a href="#Simple Calendar Time">Simple Calendar Time</a>
+<li>ERASE character: <a href="#Editing Characters">Editing Characters</a>
+<li>errno: <a href="#System Calls">System Calls</a>
+<li>error codes: <a href="#Error Reporting">Error Reporting</a>
+<li>error messages, in argp: <a href="#Argp Helper Functions">Argp Helper Functions</a>
+<li>error reporting: <a href="#Error Reporting">Error Reporting</a>
+<li>errors, mathematical: <a href="#Math Error Reporting">Math Error Reporting</a>
+<li>establishing a handler: <a href="#Signal Actions">Signal Actions</a>
+<li>ethers: <a href="#NSS Basics">NSS Basics</a>
+<li>EUC: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>EUC-JP: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li>exception: <a href="#Program Error Signals">Program Error Signals</a>, <a href="#FP Exceptions">FP Exceptions</a>
+<li>exclusive lock: <a href="#File Locks">File Locks</a>
+<li><code>exec</code> functions: <a href="#Executing a File">Executing a File</a>
+<li>execing a program: <a href="#Memory Concepts">Memory Concepts</a>
+<li>executable: <a href="#Memory Concepts">Memory Concepts</a>
+<li>executing a file: <a href="#Executing a File">Executing a File</a>
+<li>exit status: <a href="#Exit Status">Exit Status</a>
+<li>exit status value: <a href="#Program Termination">Program Termination</a>
+<li>exiting a program: <a href="#Memory Concepts">Memory Concepts</a>
+<li>expansion of shell words: <a href="#Word Expansion">Word Expansion</a>
+<li>exponent (of floating point number): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>exponentiation functions: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li>extending <code>printf</code>: <a href="#Customizing Printf">Customizing Printf</a>
+<li>extracting file descriptor from stream: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><code>fcntl</code> function: <a href="#Control Operations">Control Operations</a>
+<li>FDL, GNU Free Documentation License: <a href="#Documentation License">Documentation License</a>
+<li>feature test macros: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li>field splitting: <a href="#Expansion Stages">Expansion Stages</a>
+<li>FIFO special file: <a href="#Pipes and FIFOs">Pipes and FIFOs</a>
+<li>file access permission: <a href="#Access Permission">Access Permission</a>
+<li>file access time: <a href="#File Times">File Times</a>
+<li>file attribute modification time: <a href="#File Times">File Times</a>
+<li>file attributes: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li>file creation mask: <a href="#Setting Permissions">Setting Permissions</a>
+<li>file descriptor flags: <a href="#Descriptor Flags">Descriptor Flags</a>
+<li>file descriptor sets, for <code>select</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li>file descriptors, standard: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li>file locks: <a href="#File Locks">File Locks</a>
+<li>file modification time: <a href="#File Times">File Times</a>
+<li>file name: <a href="#File Names">File Names</a>
 <li>file name component: <a href="#Directories">Directories</a>
-<li>file name errors: <a href="#File%20Name%20Errors">File Name Errors</a>
-<li>file name resolution: <a href="#File%20Name%20Resolution">File Name Resolution</a>
-<li>file name translation flags: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>file names, multiple: <a href="#Hard%20Links">Hard Links</a>
-<li>file owner: <a href="#File%20Owner">File Owner</a>
-<li>file permission bits: <a href="#Permission%20Bits">Permission Bits</a>
+<li>file name errors: <a href="#File Name Errors">File Name Errors</a>
+<li>file name resolution: <a href="#File Name Resolution">File Name Resolution</a>
+<li>file name translation flags: <a href="#Open-time Flags">Open-time Flags</a>
+<li>file names, multiple: <a href="#Hard Links">Hard Links</a>
+<li>file owner: <a href="#File Owner">File Owner</a>
+<li>file permission bits: <a href="#Permission Bits">Permission Bits</a>
 <li>file pointer: <a href="#Streams">Streams</a>
-<li>file position: <a href="#File%20Position">File Position</a>
-<li>file positioning on a file descriptor: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li>file positioning on a stream: <a href="#File%20Positioning">File Positioning</a>
-<li>file status flags: <a href="#File%20Status%20Flags">File Status Flags</a>
-<li>files, accessing: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>filtering i/o through subprocess: <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>
-<li>flag character (<code>printf</code>): <a href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>
-<li>flag character (<code>scanf</code>): <a href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>
-<li>flags for <code>sigaction</code>: <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>
-<li>flags, file name translation: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>flags, open-time action: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>floating point: <a href="#Floating%20Point%20Numbers">Floating Point Numbers</a>
-<li>floating point, IEEE: <a href="#IEEE%20Floating%20Point">IEEE Floating Point</a>
-<li>floating type measurements: <a href="#Floating%20Type%20Macros">Floating Type Macros</a>
-<li>floating-point classes: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li>floating-point exception: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li>flow control, terminal: <a href="#Line%20Control">Line Control</a>
-<li>flushing a stream: <a href="#Flushing%20Buffers">Flushing Buffers</a>
-<li>flushing terminal output queue: <a href="#Line%20Control">Line Control</a>
-<li>foreground job: <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>
-<li>foreground job, launching: <a href="#Foreground%20and%20Background">Foreground and Background</a>
-<li>forking a process: <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>
-<li>format string, for <code>printf</code>: <a href="#Formatted%20Output">Formatted Output</a>
-<li>format string, for <code>scanf</code>: <a href="#Formatted%20Input">Formatted Input</a>
-<li>formatted input from a stream: <a href="#Formatted%20Input">Formatted Input</a>
-<li>formatted messages: <a href="#Formatted%20Messages">Formatted Messages</a>
-<li>formatted output to a stream: <a href="#Formatted%20Output">Formatted Output</a>
-<li>FP arithmetic: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li>FQDN: <a href="#Host%20Identification">Host Identification</a>
-<li>frame, real memory: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>free documentation: <a href="#Free%20Manuals">Free Manuals</a>
-<li>freeing (obstacks): <a href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>
-<li>freeing memory: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>freeing memory allocated with <code>malloc</code>: <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>
-<li>fully buffered stream: <a href="#Buffering%20Concepts">Buffering Concepts</a>
-<li>function prototypes (variadic): <a href="#Variadic%20Prototypes">Variadic Prototypes</a>
-<li>gamma function: <a href="#Special%20Functions">Special Functions</a>
-<li>gcvt_r: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li>gencat: <a href="#The%20gencat%20program">The gencat program</a>
-<li>generation of signals: <a href="#Signal%20Generation">Signal Generation</a>
+<li>file position: <a href="#File Position">File Position</a>
+<li>file positioning on a file descriptor: <a href="#File Position Primitive">File Position Primitive</a>
+<li>file positioning on a stream: <a href="#File Positioning">File Positioning</a>
+<li>file status flags: <a href="#File Status Flags">File Status Flags</a>
+<li>files, accessing: <a href="#Memory Concepts">Memory Concepts</a>
+<li>filtering i/o through subprocess: <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>
+<li>flag character (<code>printf</code>): <a href="#Output Conversion Syntax">Output Conversion Syntax</a>
+<li>flag character (<code>scanf</code>): <a href="#Input Conversion Syntax">Input Conversion Syntax</a>
+<li>flags for <code>sigaction</code>: <a href="#Flags for Sigaction">Flags for Sigaction</a>
+<li>flags, file name translation: <a href="#Open-time Flags">Open-time Flags</a>
+<li>flags, open-time action: <a href="#Open-time Flags">Open-time Flags</a>
+<li>floating point: <a href="#Floating Point Numbers">Floating Point Numbers</a>
+<li>floating point, IEEE: <a href="#IEEE Floating Point">IEEE Floating Point</a>
+<li>floating type measurements: <a href="#Floating Type Macros">Floating Type Macros</a>
+<li>floating-point classes: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li>floating-point exception: <a href="#Program Error Signals">Program Error Signals</a>
+<li>flow control, terminal: <a href="#Line Control">Line Control</a>
+<li>flushing a stream: <a href="#Flushing Buffers">Flushing Buffers</a>
+<li>flushing terminal output queue: <a href="#Line Control">Line Control</a>
+<li>foreground job: <a href="#Concepts of Job Control">Concepts of Job Control</a>
+<li>foreground job, launching: <a href="#Foreground and Background">Foreground and Background</a>
+<li>forking a process: <a href="#Process Creation Concepts">Process Creation Concepts</a>
+<li>format string, for <code>printf</code>: <a href="#Formatted Output">Formatted Output</a>
+<li>format string, for <code>scanf</code>: <a href="#Formatted Input">Formatted Input</a>
+<li>formatted input from a stream: <a href="#Formatted Input">Formatted Input</a>
+<li>formatted messages: <a href="#Formatted Messages">Formatted Messages</a>
+<li>formatted output to a stream: <a href="#Formatted Output">Formatted Output</a>
+<li>FP arithmetic: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li>FQDN: <a href="#Host Identification">Host Identification</a>
+<li>frame, real memory: <a href="#Memory Concepts">Memory Concepts</a>
+<li>free documentation: <a href="#Free Manuals">Free Manuals</a>
+<li>freeing (obstacks): <a href="#Freeing Obstack Objects">Freeing Obstack Objects</a>
+<li>freeing memory: <a href="#Memory Concepts">Memory Concepts</a>
+<li>freeing memory allocated with <code>malloc</code>: <a href="#Freeing after Malloc">Freeing after Malloc</a>
+<li>fully buffered stream: <a href="#Buffering Concepts">Buffering Concepts</a>
+<li>function prototypes (variadic): <a href="#Variadic Prototypes">Variadic Prototypes</a>
+<li>gamma function: <a href="#Special Functions">Special Functions</a>
+<li>gcvt_r: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li>gencat: <a href="#The gencat program">The gencat program</a>
+<li>generation of signals: <a href="#Signal Generation">Signal Generation</a>
 <li>generic i/o control operations: <a href="#IOCTLs">IOCTLs</a>
 <li>globbing: <a href="#Globbing">Globbing</a>
-<li>graphic character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>Gregorian calendar: <a href="#Calendar%20Time">Calendar Time</a>
-<li>group: <a href="#NSS%20Basics">NSS Basics</a>
-<li>group database: <a href="#Group%20Database">Group Database</a>
-<li>group ID: <a href="#User%20and%20Group%20IDs">User and Group IDs</a>
-<li>group name: <a href="#User%20and%20Group%20IDs">User and Group IDs</a>
-<li>group owner of a file: <a href="#File%20Owner">File Owner</a>
-<li>grouping of digits: <a href="#General%20Numeric">General Numeric</a>
-<li>growing objects (in obstacks): <a href="#Growing%20Objects">Growing Objects</a>
-<li>handling multiple signals: <a href="#Merged%20Signals">Merged Signals</a>
-<li>hangup signal: <a href="#Termination%20Signals">Termination Signals</a>
-<li>hard limit: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li>hard link: <a href="#Hard%20Links">Hard Links</a>
-<li>header files: <a href="#Header%20Files">Header Files</a>
-<li>heap consistency checking: <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>
-<li>heap, dynamic allocation from: <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
-<li>heap, freeing memory from: <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>
-<li>hexadecimal digit character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>hidden bit (of floating point number mantissa): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>hierarchy, directory: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li>high-priority data: <a href="#Out-of-Band%20Data">Out-of-Band Data</a>
-<li>high-resolution time: <a href="#Calendar%20Time">Calendar Time</a>
-<li>holes in files: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li>home directory: <a href="#Standard%20Environment">Standard Environment</a>
-<li><code>HOME</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>hook functions (of custom streams): <a href="#Hook%20Functions">Hook Functions</a>
-<li>host address, Internet: <a href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>
-<li>host name: <a href="#Host%20Identification">Host Identification</a>
-<li>hostname: <a href="#Host%20Identification">Host Identification</a>
-<li>hosts: <a href="#NSS%20Basics">NSS Basics</a>
-<li>hosts database: <a href="#Host%20Names">Host Names</a>
-<li>how many arguments: <a href="#How%20Many%20Arguments">How Many Arguments</a>
-<li>hyperbolic functions: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li>identifying terminals: <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>
-<li>IEEE 754: <a href="#Floating%20Point%20Numbers">Floating Point Numbers</a>
-<li>IEEE floating point: <a href="#Floating%20Point%20Numbers">Floating Point Numbers</a>
-<li>IEEE floating point representation: <a href="#IEEE%20Floating%20Point">IEEE Floating Point</a>
+<li>graphic character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>Gregorian calendar: <a href="#Calendar Time">Calendar Time</a>
+<li>group: <a href="#NSS Basics">NSS Basics</a>
+<li>group database: <a href="#Group Database">Group Database</a>
+<li>group ID: <a href="#User and Group IDs">User and Group IDs</a>
+<li>group name: <a href="#User and Group IDs">User and Group IDs</a>
+<li>group owner of a file: <a href="#File Owner">File Owner</a>
+<li>grouping of digits: <a href="#General Numeric">General Numeric</a>
+<li>growing objects (in obstacks): <a href="#Growing Objects">Growing Objects</a>
+<li>handling multiple signals: <a href="#Merged Signals">Merged Signals</a>
+<li>hangup signal: <a href="#Termination Signals">Termination Signals</a>
+<li>hard limit: <a href="#Limits on Resources">Limits on Resources</a>
+<li>hard link: <a href="#Hard Links">Hard Links</a>
+<li>header files: <a href="#Header Files">Header Files</a>
+<li>heap consistency checking: <a href="#Heap Consistency Checking">Heap Consistency Checking</a>
+<li>heap, dynamic allocation from: <a href="#Unconstrained Allocation">Unconstrained Allocation</a>
+<li>heap, freeing memory from: <a href="#Freeing after Malloc">Freeing after Malloc</a>
+<li>hexadecimal digit character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>hidden bit (of floating point number mantissa): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>hierarchy, directory: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li>high-priority data: <a href="#Out-of-Band Data">Out-of-Band Data</a>
+<li>high-resolution time: <a href="#Calendar Time">Calendar Time</a>
+<li>holes in files: <a href="#File Position Primitive">File Position Primitive</a>
+<li>home directory: <a href="#Standard Environment">Standard Environment</a>
+<li><code>HOME</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>hook functions (of custom streams): <a href="#Hook Functions">Hook Functions</a>
+<li>host address, Internet: <a href="#Abstract Host Addresses">Abstract Host Addresses</a>
+<li>host name: <a href="#Host Identification">Host Identification</a>
+<li>hostname: <a href="#Host Identification">Host Identification</a>
+<li>hosts: <a href="#NSS Basics">NSS Basics</a>
+<li>hosts database: <a href="#Host Names">Host Names</a>
+<li>how many arguments: <a href="#How Many Arguments">How Many Arguments</a>
+<li>hyperbolic functions: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li>identifying terminals: <a href="#Is It a Terminal">Is It a Terminal</a>
+<li>IEEE 754: <a href="#Floating Point Numbers">Floating Point Numbers</a>
+<li>IEEE floating point: <a href="#Floating Point Numbers">Floating Point Numbers</a>
+<li>IEEE floating point representation: <a href="#IEEE Floating Point">IEEE Floating Point</a>
 <li>IEEE Std 1003.1: <a href="#POSIX">POSIX</a>
 <li>IEEE Std 1003.2: <a href="#POSIX">POSIX</a>
-<li>ignore action for a signal: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li>illegal instruction: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li>impossible events: <a href="#Consistency%20Checking">Consistency Checking</a>
-<li>independent channels: <a href="#Independent%20Channels">Independent Channels</a>
-<li>inexact exception: <a href="#FP%20Exceptions">FP Exceptions</a>
-<li>infinity: <a href="#Infinity%20and%20NaN">Infinity and NaN</a>
-<li>initial signal actions: <a href="#Initial%20Signal%20Actions">Initial Signal Actions</a>
-<li>inode number: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li>input available signal: <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>
-<li>input conversions, for <code>scanf</code>: <a href="#Table%20of%20Input%20Conversions">Table of Input Conversions</a>
-<li>input from multiple files: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li>installation tools: <a href="#Tools%20for%20Compilation">Tools for Compilation</a>
-<li>installing: <a href="#Running%20make%20install">Running make install</a>
+<li>ignore action for a signal: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li>illegal instruction: <a href="#Program Error Signals">Program Error Signals</a>
+<li>impossible events: <a href="#Consistency Checking">Consistency Checking</a>
+<li>independent channels: <a href="#Independent Channels">Independent Channels</a>
+<li>inexact exception: <a href="#FP Exceptions">FP Exceptions</a>
+<li>infinity: <a href="#Infinity and NaN">Infinity and NaN</a>
+<li>initial signal actions: <a href="#Initial Signal Actions">Initial Signal Actions</a>
+<li>inode number: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li>input available signal: <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>
+<li>input conversions, for <code>scanf</code>: <a href="#Table of Input Conversions">Table of Input Conversions</a>
+<li>input from multiple files: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li>installation tools: <a href="#Tools for Compilation">Tools for Compilation</a>
+<li>installing: <a href="#Running make install">Running make install</a>
 <li>integer: <a href="#Integers">Integers</a>
-<li>integer division functions: <a href="#Integer%20Division">Integer Division</a>
-<li>integer type range: <a href="#Range%20of%20Type">Range of Type</a>
-<li>integer type width: <a href="#Width%20of%20Type">Width of Type</a>
-<li>interactive signals, from terminal: <a href="#Local%20Modes">Local Modes</a>
-<li>interactive stop signal: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li>internal representation: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
+<li>integer division functions: <a href="#Integer Division">Integer Division</a>
+<li>integer type range: <a href="#Range of Type">Range of Type</a>
+<li>integer type width: <a href="#Width of Type">Width of Type</a>
+<li>interactive signals, from terminal: <a href="#Local Modes">Local Modes</a>
+<li>interactive stop signal: <a href="#Job Control Signals">Job Control Signals</a>
+<li>internal representation: <a href="#Extended Char Intro">Extended Char Intro</a>
 <li>internationalization: <a href="#Locales">Locales</a>
-<li>Internet host address: <a href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>
-<li>Internet namespace, for sockets: <a href="#Internet%20Namespace">Internet Namespace</a>
-<li>interprocess communication, with FIFO: <a href="#FIFO%20Special%20Files">FIFO Special Files</a>
-<li>interprocess communication, with pipes: <a href="#Creating%20a%20Pipe">Creating a Pipe</a>
-<li>interprocess communication, with signals: <a href="#Kill%20Example">Kill Example</a>
+<li>Internet host address: <a href="#Abstract Host Addresses">Abstract Host Addresses</a>
+<li>Internet namespace, for sockets: <a href="#Internet Namespace">Internet Namespace</a>
+<li>interprocess communication, with FIFO: <a href="#FIFO Special Files">FIFO Special Files</a>
+<li>interprocess communication, with pipes: <a href="#Creating a Pipe">Creating a Pipe</a>
+<li>interprocess communication, with signals: <a href="#Kill Example">Kill Example</a>
 <li>interprocess communication, with sockets: <a href="#Sockets">Sockets</a>
-<li>interrupt character: <a href="#Signal%20Characters">Signal Characters</a>
-<li>interrupt signal: <a href="#Termination%20Signals">Termination Signals</a>
-<li>interrupt-driven input: <a href="#Interrupt%20Input">Interrupt Input</a>
-<li>interrupting primitives: <a href="#Interrupted%20Primitives">Interrupted Primitives</a>
-<li>interval: <a href="#Time%20Basics">Time Basics</a>
-<li>interval timer, setting: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>INTR character: <a href="#Signal%20Characters">Signal Characters</a>
-<li>invalid exception: <a href="#FP%20Exceptions">FP Exceptions</a>
-<li>inverse complex hyperbolic functions: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li>inverse complex trigonometric functions: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li>inverse hyperbolic functions: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li>inverse trigonometric functions: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li>invocation of program: <a href="#Program%20Arguments">Program Arguments</a>
+<li>interrupt character: <a href="#Signal Characters">Signal Characters</a>
+<li>interrupt signal: <a href="#Termination Signals">Termination Signals</a>
+<li>interrupt-driven input: <a href="#Interrupt Input">Interrupt Input</a>
+<li>interrupting primitives: <a href="#Interrupted Primitives">Interrupted Primitives</a>
+<li>interval: <a href="#Time Basics">Time Basics</a>
+<li>interval timer, setting: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>INTR character: <a href="#Signal Characters">Signal Characters</a>
+<li>invalid exception: <a href="#FP Exceptions">FP Exceptions</a>
+<li>inverse complex hyperbolic functions: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li>inverse complex trigonometric functions: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li>inverse hyperbolic functions: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li>inverse trigonometric functions: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li>invocation of program: <a href="#Program Arguments">Program Arguments</a>
 <li>IOCTLs: <a href="#IOCTLs">IOCTLs</a>
-<li>ISO 10646: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>ISO 2022: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>ISO 6937: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>ISO C: <a href="#ISO%20C">ISO C</a>
-<li>ISO-2022-JP: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
+<li>ISO 10646: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>ISO 2022: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>ISO 6937: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>ISO C: <a href="#ISO C">ISO C</a>
+<li>ISO-2022-JP: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
 <li>ISO/IEC 9945-1: <a href="#POSIX">POSIX</a>
 <li>ISO/IEC 9945-2: <a href="#POSIX">POSIX</a>
-<li>job: <a href="#Job%20Control">Job Control</a>
-<li>job control: <a href="#Job%20Control">Job Control</a>
-<li>job control functions: <a href="#Functions%20for%20Job%20Control">Functions for Job Control</a>
-<li>job control is optional: <a href="#Job%20Control%20is%20Optional">Job Control is Optional</a>
-<li>job control signals: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li>job control, enabling: <a href="#Initializing%20the%20Shell">Initializing the Shell</a>
-<li>Kermit the frog: <a href="#Search%2fSort%20Example">Search/Sort Example</a>
-<li>kernel call: <a href="#System%20Calls">System Calls</a>
+<li>job: <a href="#Job Control">Job Control</a>
+<li>job control: <a href="#Job Control">Job Control</a>
+<li>job control functions: <a href="#Functions for Job Control">Functions for Job Control</a>
+<li>job control is optional: <a href="#Job Control is Optional">Job Control is Optional</a>
+<li>job control signals: <a href="#Job Control Signals">Job Control Signals</a>
+<li>job control, enabling: <a href="#Initializing the Shell">Initializing the Shell</a>
+<li>Kermit the frog: <a href="#Search%2fSort Example">Search/Sort Example</a>
+<li>kernel call: <a href="#System Calls">System Calls</a>
 <li>kernel header files: <a href="#Linux">Linux</a>
-<li>KILL character: <a href="#Editing%20Characters">Editing Characters</a>
-<li>kill signal: <a href="#Termination%20Signals">Termination Signals</a>
-<li>killing a process: <a href="#Signaling%20Another%20Process">Signaling Another Process</a>
-<li>Korn Shell: <a href="#Wildcard%20Matching">Wildcard Matching</a>
-<li><code>LANG</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>LANG environment variable: <a href="#The%20catgets%20Functions">The catgets Functions</a>
-<li>launching jobs: <a href="#Launching%20Jobs">Launching Jobs</a>
-<li><code>LC_ALL</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>LC_ALL environment variable: <a href="#The%20catgets%20Functions">The catgets Functions</a>
-<li><code>LC_COLLATE</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li><code>LC_CTYPE</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li><code>LC_MESSAGES</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>LC_MESSAGES environment variable: <a href="#The%20catgets%20Functions">The catgets Functions</a>
-<li><code>LC_MONETARY</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li><code>LC_NUMERIC</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li><code>LC_TIME</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>leap second: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li>length of string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>level, for socket options: <a href="#Socket%20Options">Socket Options</a>
+<li>KILL character: <a href="#Editing Characters">Editing Characters</a>
+<li>kill signal: <a href="#Termination Signals">Termination Signals</a>
+<li>killing a process: <a href="#Signaling Another Process">Signaling Another Process</a>
+<li>Korn Shell: <a href="#Wildcard Matching">Wildcard Matching</a>
+<li><code>LANG</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>LANG environment variable: <a href="#The catgets Functions">The catgets Functions</a>
+<li>launching jobs: <a href="#Launching Jobs">Launching Jobs</a>
+<li><code>LC_ALL</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>LC_ALL environment variable: <a href="#The catgets Functions">The catgets Functions</a>
+<li><code>LC_COLLATE</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li><code>LC_CTYPE</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li><code>LC_MESSAGES</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>LC_MESSAGES environment variable: <a href="#The catgets Functions">The catgets Functions</a>
+<li><code>LC_MONETARY</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li><code>LC_NUMERIC</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li><code>LC_TIME</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>leap second: <a href="#Broken-down Time">Broken-down Time</a>
+<li>length of string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>level, for socket options: <a href="#Socket Options">Socket Options</a>
 <li>LGPL, Lesser General Public License: <a href="#Copying">Copying</a>
 <li>library: <a href="#Introduction">Introduction</a>
-<li>limit: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li>limits on resource usage: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li>limits, file name length: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li>limits, floating types: <a href="#Floating%20Type%20Macros">Floating Type Macros</a>
-<li>limits, integer types: <a href="#Range%20of%20Type">Range of Type</a>
-<li>limits, link count of files: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li>limits, number of open files: <a href="#General%20Limits">General Limits</a>
-<li>limits, number of processes: <a href="#General%20Limits">General Limits</a>
-<li>limits, number of supplementary group IDs: <a href="#General%20Limits">General Limits</a>
-<li>limits, pipe buffer size: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li>limits, POSIX: <a href="#General%20Limits">General Limits</a>
-<li>limits, program argument size: <a href="#General%20Limits">General Limits</a>
-<li>limits, terminal input queue: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li>limits, time zone name length: <a href="#General%20Limits">General Limits</a>
-<li>line buffered stream: <a href="#Buffering%20Concepts">Buffering Concepts</a>
-<li>line speed: <a href="#Line%20Speed">Line Speed</a>
-<li>lines (in a text file): <a href="#Binary%20Streams">Binary Streams</a>
+<li>limit: <a href="#Limits on Resources">Limits on Resources</a>
+<li>limits on resource usage: <a href="#Limits on Resources">Limits on Resources</a>
+<li>limits, file name length: <a href="#Limits for Files">Limits for Files</a>
+<li>limits, floating types: <a href="#Floating Type Macros">Floating Type Macros</a>
+<li>limits, integer types: <a href="#Range of Type">Range of Type</a>
+<li>limits, link count of files: <a href="#Limits for Files">Limits for Files</a>
+<li>limits, number of open files: <a href="#General Limits">General Limits</a>
+<li>limits, number of processes: <a href="#General Limits">General Limits</a>
+<li>limits, number of supplementary group IDs: <a href="#General Limits">General Limits</a>
+<li>limits, pipe buffer size: <a href="#Limits for Files">Limits for Files</a>
+<li>limits, POSIX: <a href="#General Limits">General Limits</a>
+<li>limits, program argument size: <a href="#General Limits">General Limits</a>
+<li>limits, terminal input queue: <a href="#Limits for Files">Limits for Files</a>
+<li>limits, time zone name length: <a href="#General Limits">General Limits</a>
+<li>line buffered stream: <a href="#Buffering Concepts">Buffering Concepts</a>
+<li>line speed: <a href="#Line Speed">Line Speed</a>
+<li>lines (in a text file): <a href="#Binary Streams">Binary Streams</a>
 <li>link: <a href="#Directories">Directories</a>
-<li>link, hard: <a href="#Hard%20Links">Hard Links</a>
-<li>link, soft: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li>link, symbolic: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li>linked channels: <a href="#Linked%20Channels">Linked Channels</a>
+<li>link, hard: <a href="#Hard Links">Hard Links</a>
+<li>link, soft: <a href="#Symbolic Links">Symbolic Links</a>
+<li>link, symbolic: <a href="#Symbolic Links">Symbolic Links</a>
+<li>linked channels: <a href="#Linked Channels">Linked Channels</a>
 <li>listening (sockets): <a href="#Listening">Listening</a>
-<li>literals: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>little-endian: <a href="#Byte%20Order">Byte Order</a>
-<li>LNEXT character: <a href="#Other%20Special">Other Special</a>
-<li>load average: <a href="#Processor%20Resources">Processor Resources</a>
-<li>local namespace, for sockets: <a href="#Local%20Namespace">Local Namespace</a>
-<li>local network address number: <a href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>
-<li>local time: <a href="#Calendar%20Time">Calendar Time</a>
-<li>locale categories: <a href="#Locale%20Categories">Locale Categories</a>
-<li>locale, changing: <a href="#Setting%20the%20Locale">Setting the Locale</a>
+<li>literals: <a href="#Memory Concepts">Memory Concepts</a>
+<li>little-endian: <a href="#Byte Order">Byte Order</a>
+<li>LNEXT character: <a href="#Other Special">Other Special</a>
+<li>load average: <a href="#Processor Resources">Processor Resources</a>
+<li>local namespace, for sockets: <a href="#Local Namespace">Local Namespace</a>
+<li>local network address number: <a href="#Abstract Host Addresses">Abstract Host Addresses</a>
+<li>local time: <a href="#Calendar Time">Calendar Time</a>
+<li>locale categories: <a href="#Locale Categories">Locale Categories</a>
+<li>locale, changing: <a href="#Setting the Locale">Setting the Locale</a>
 <li>locales: <a href="#Locales">Locales</a>
-<li>locking pages: <a href="#Locking%20Pages">Locking Pages</a>
-<li>logarithm functions: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li>login name: <a href="#User%20and%20Group%20IDs">User and Group IDs</a>
-<li>login name, determining: <a href="#Who%20Logged%20In">Who Logged In</a>
-<li><code>LOGNAME</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>long jumps: <a href="#Non-Local%20Exits">Non-Local Exits</a>
-<li>long-named options: <a href="#Argument%20Syntax">Argument Syntax</a>
-<li>longjmp: <a href="#Advantages%20of%20Alloca">Advantages of Alloca</a>
-<li>loss of data on sockets: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>lost resource signal: <a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li>lower-case character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>macros: <a href="#Obstack%20Functions">Obstack Functions</a>
-<li><code>main</code> function: <a href="#Program%20Arguments">Program Arguments</a>
-<li>malloc debugger: <a href="#Allocation%20Debugging">Allocation Debugging</a>
-<li><code>malloc</code> function: <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
-<li>mantissa (of floating point number): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>matching failure, in <code>scanf</code>: <a href="#Formatted%20Input%20Basics">Formatted Input Basics</a>
-<li>math errors: <a href="#Errors%20in%20Math%20Functions">Errors in Math Functions</a>
-<li>mathematical constants: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li>maximum: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li>maximum field width (<code>scanf</code>): <a href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>
-<li>maximum limit: <a href="#Limits%20on%20Resources">Limits on Resources</a>
+<li>locking pages: <a href="#Locking Pages">Locking Pages</a>
+<li>logarithm functions: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li>login name: <a href="#User and Group IDs">User and Group IDs</a>
+<li>login name, determining: <a href="#Who Logged In">Who Logged In</a>
+<li><code>LOGNAME</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>long jumps: <a href="#Non-Local Exits">Non-Local Exits</a>
+<li>long-named options: <a href="#Argument Syntax">Argument Syntax</a>
+<li>longjmp: <a href="#Advantages of Alloca">Advantages of Alloca</a>
+<li>loss of data on sockets: <a href="#Socket Concepts">Socket Concepts</a>
+<li>lost resource signal: <a href="#Operation Error Signals">Operation Error Signals</a>
+<li>lower-case character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>macros: <a href="#Obstack Functions">Obstack Functions</a>
+<li><code>main</code> function: <a href="#Program Arguments">Program Arguments</a>
+<li>malloc debugger: <a href="#Allocation Debugging">Allocation Debugging</a>
+<li><code>malloc</code> function: <a href="#Unconstrained Allocation">Unconstrained Allocation</a>
+<li>mantissa (of floating point number): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>matching failure, in <code>scanf</code>: <a href="#Formatted Input Basics">Formatted Input Basics</a>
+<li>math errors: <a href="#Errors in Math Functions">Errors in Math Functions</a>
+<li>mathematical constants: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li>maximum: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li>maximum field width (<code>scanf</code>): <a href="#Input Conversion Syntax">Input Conversion Syntax</a>
+<li>maximum limit: <a href="#Limits on Resources">Limits on Resources</a>
 <li>maximum possible integer: <a href="#Integers">Integers</a>
-<li>measurements of floating types: <a href="#Floating%20Type%20Macros">Floating Type Macros</a>
+<li>measurements of floating types: <a href="#Floating Type Macros">Floating Type Macros</a>
 <li>memory allocation: <a href="#Memory">Memory</a>
-<li>memory lock: <a href="#Locking%20Pages">Locking Pages</a>
-<li>memory mapped file: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>memory mapped I/O: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>memory page: <a href="#Memory%20Subsystem">Memory Subsystem</a>
-<li>merging of signals: <a href="#Merged%20Signals">Merged Signals</a>
-<li>MIN termios slot: <a href="#Noncanonical%20Input">Noncanonical Input</a>
-<li>minimum: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li>minimum field width (<code>printf</code>): <a href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>
+<li>memory lock: <a href="#Locking Pages">Locking Pages</a>
+<li>memory mapped file: <a href="#Memory Concepts">Memory Concepts</a>
+<li>memory mapped I/O: <a href="#Memory Concepts">Memory Concepts</a>
+<li>memory page: <a href="#Memory Subsystem">Memory Subsystem</a>
+<li>merging of signals: <a href="#Merged Signals">Merged Signals</a>
+<li>MIN termios slot: <a href="#Noncanonical Input">Noncanonical Input</a>
+<li>minimum: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li>minimum field width (<code>printf</code>): <a href="#Output Conversion Syntax">Output Conversion Syntax</a>
 <li>minimum possible integer: <a href="#Integers">Integers</a>
-<li>mixing descriptors and streams: <a href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>
-<li>modem disconnect: <a href="#Control%20Modes">Control Modes</a>
-<li>modem status lines: <a href="#Control%20Modes">Control Modes</a>
-<li>monetary value formatting: <a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>
-<li>multi-threaded application: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li>multibyte character: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>multibyte character string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>multibyte string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>multiple names for one file: <a href="#Hard%20Links">Hard Links</a>
-<li>multiplexing input: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li>multiply-add: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li>name of running program: <a href="#Error%20Messages">Error Messages</a>
-<li>name of socket: <a href="#Socket%20Addresses">Socket Addresses</a>
-<li>Name Service Switch: <a href="#Name%20Service%20Switch">Name Service Switch</a>
-<li>name space: <a href="#Reserved%20Names">Reserved Names</a>
-<li>names of signals: <a href="#Standard%20Signals">Standard Signals</a>
-<li>namespace (of socket): <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>NaN: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>, <a href="#Infinity%20and%20NaN">Infinity and NaN</a>
-<li>Netgroup: <a href="#Netgroup%20Data">Netgroup Data</a>
-<li>netgroup: <a href="#NSS%20Basics">NSS Basics</a>
-<li>network byte order: <a href="#Byte%20Order">Byte Order</a>
-<li>network number: <a href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>
-<li>network protocol: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>networks: <a href="#NSS%20Basics">NSS Basics</a>
-<li>networks database: <a href="#Networks%20Database">Networks Database</a>
-<li>NIS: <a href="#Host%20Identification">Host Identification</a>
-<li>NIS domain name: <a href="#Host%20Identification">Host Identification</a>
-<li>nisplus, and booting: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li>nisplus, and completeness: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li><code>NLSPATH</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>NLSPATH environment variable: <a href="#The%20catgets%20Functions">The catgets Functions</a>
-<li>non-blocking open: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>non-local exit, from signal handler: <a href="#Longjmp%20in%20Handler">Longjmp in Handler</a>
-<li>non-local exits: <a href="#Non-Local%20Exits">Non-Local Exits</a>
-<li>noncanonical input processing: <a href="#Canonical%20or%20Not">Canonical or Not</a>
-<li>normalization functions (floating-point): <a href="#Normalization%20Functions">Normalization Functions</a>
-<li>normalized floating point number: <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>not a number: <a href="#Infinity%20and%20NaN">Infinity and NaN</a>
-<li>NSS: <a href="#Name%20Service%20Switch">Name Service Switch</a>
-<li><code>nsswitch.conf</code>: <a href="#NSS%20Configuration%20File">NSS Configuration File</a>
-<li>null character: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>null pointer constant: <a href="#Null%20Pointer%20Constant">Null Pointer Constant</a>
-<li>null wide character: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>number of arguments passed: <a href="#How%20Many%20Arguments">How Many Arguments</a>
-<li>number syntax, parsing: <a href="#Parsing%20of%20Numbers">Parsing of Numbers</a>
-<li>numeric value formatting: <a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>
-<li>obstack status: <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>
+<li>mixing descriptors and streams: <a href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>
+<li>modem disconnect: <a href="#Control Modes">Control Modes</a>
+<li>modem status lines: <a href="#Control Modes">Control Modes</a>
+<li>monetary value formatting: <a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>
+<li>multi-threaded application: <a href="#Streams and Threads">Streams and Threads</a>
+<li>multibyte character: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>multibyte character string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>multibyte string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>multiple names for one file: <a href="#Hard Links">Hard Links</a>
+<li>multiplexing input: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li>multiply-add: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li>name of running program: <a href="#Error Messages">Error Messages</a>
+<li>name of socket: <a href="#Socket Addresses">Socket Addresses</a>
+<li>Name Service Switch: <a href="#Name Service Switch">Name Service Switch</a>
+<li>name space: <a href="#Reserved Names">Reserved Names</a>
+<li>names of signals: <a href="#Standard Signals">Standard Signals</a>
+<li>namespace (of socket): <a href="#Socket Concepts">Socket Concepts</a>
+<li>NaN: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>, <a href="#Infinity and NaN">Infinity and NaN</a>
+<li>Netgroup: <a href="#Netgroup Data">Netgroup Data</a>
+<li>netgroup: <a href="#NSS Basics">NSS Basics</a>
+<li>network byte order: <a href="#Byte Order">Byte Order</a>
+<li>network number: <a href="#Abstract Host Addresses">Abstract Host Addresses</a>
+<li>network protocol: <a href="#Socket Concepts">Socket Concepts</a>
+<li>networks: <a href="#NSS Basics">NSS Basics</a>
+<li>networks database: <a href="#Networks Database">Networks Database</a>
+<li>NIS: <a href="#Host Identification">Host Identification</a>
+<li>NIS domain name: <a href="#Host Identification">Host Identification</a>
+<li>nisplus, and booting: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li>nisplus, and completeness: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li><code>NLSPATH</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>NLSPATH environment variable: <a href="#The catgets Functions">The catgets Functions</a>
+<li>non-blocking open: <a href="#Open-time Flags">Open-time Flags</a>
+<li>non-local exit, from signal handler: <a href="#Longjmp in Handler">Longjmp in Handler</a>
+<li>non-local exits: <a href="#Non-Local Exits">Non-Local Exits</a>
+<li>noncanonical input processing: <a href="#Canonical or Not">Canonical or Not</a>
+<li>normalization functions (floating-point): <a href="#Normalization Functions">Normalization Functions</a>
+<li>normalized floating point number: <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>not a number: <a href="#Infinity and NaN">Infinity and NaN</a>
+<li>NSS: <a href="#Name Service Switch">Name Service Switch</a>
+<li><code>nsswitch.conf</code>: <a href="#NSS Configuration File">NSS Configuration File</a>
+<li>null character: <a href="#Representation of Strings">Representation of Strings</a>
+<li>null pointer constant: <a href="#Null Pointer Constant">Null Pointer Constant</a>
+<li>null wide character: <a href="#Representation of Strings">Representation of Strings</a>
+<li>number of arguments passed: <a href="#How Many Arguments">How Many Arguments</a>
+<li>number syntax, parsing: <a href="#Parsing of Numbers">Parsing of Numbers</a>
+<li>numeric value formatting: <a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>
+<li>obstack status: <a href="#Status of an Obstack">Status of an Obstack</a>
 <li>obstacks: <a href="#Obstacks">Obstacks</a>
-<li>open-time action flags: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>opening a file: <a href="#I%2fO%20Concepts">I/O Concepts</a>
-<li>opening a file descriptor: <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li>opening a pipe: <a href="#Creating%20a%20Pipe">Creating a Pipe</a>
-<li>opening a pseudo-terminal pair: <a href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>
-<li>opening a socket: <a href="#Creating%20a%20Socket">Creating a Socket</a>
-<li>opening a socket pair: <a href="#Socket%20Pairs">Socket Pairs</a>
-<li>opening a stream: <a href="#Opening%20Streams">Opening Streams</a>
-<li>Optimization: <a href="#FP%20Function%20Optimizations">FP Function Optimizations</a>
-<li>optimizing NSS: <a href="#Notes%20on%20NSS%20Configuration%20File">Notes on NSS Configuration File</a>
+<li>open-time action flags: <a href="#Open-time Flags">Open-time Flags</a>
+<li>opening a file: <a href="#I%2fO Concepts">I/O Concepts</a>
+<li>opening a file descriptor: <a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li>opening a pipe: <a href="#Creating a Pipe">Creating a Pipe</a>
+<li>opening a pseudo-terminal pair: <a href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>
+<li>opening a socket: <a href="#Creating a Socket">Creating a Socket</a>
+<li>opening a socket pair: <a href="#Socket Pairs">Socket Pairs</a>
+<li>opening a stream: <a href="#Opening Streams">Opening Streams</a>
+<li>Optimization: <a href="#FP Function Optimizations">FP Function Optimizations</a>
+<li>optimizing NSS: <a href="#Notes on NSS Configuration File">Notes on NSS Configuration File</a>
 <li>option parsing with argp: <a href="#Argp">Argp</a>
-<li>optional arguments: <a href="#Variadic%20Functions">Variadic Functions</a>
-<li>optional POSIX features: <a href="#System%20Options">System Options</a>
-<li>orientation, stream: <a href="#Streams%20and%20I18N">Streams and I18N</a>, <a href="#Opening%20Streams">Opening Streams</a>
-<li>orphaned process group: <a href="#Orphaned%20Process%20Groups">Orphaned Process Groups</a>
-<li>out-of-band data: <a href="#Out-of-Band%20Data">Out-of-Band Data</a>
-<li>output conversions, for <code>printf</code>: <a href="#Table%20of%20Output%20Conversions">Table of Output Conversions</a>
-<li>output possible signal: <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>
-<li>overflow exception: <a href="#FP%20Exceptions">FP Exceptions</a>
-<li>owner of a file: <a href="#File%20Owner">File Owner</a>
-<li>packet: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>page boundary: <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>
-<li>page fault: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>page fault, copy-on-write: <a href="#Locked%20Memory%20Details">Locked Memory Details</a>
-<li>page frame: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>page, memory: <a href="#Memory%20Subsystem">Memory Subsystem</a>
-<li>page, virtual memory: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>paging: <a href="#Locking%20Pages">Locking Pages</a>, <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>parameter promotion: <a href="#String%2fArray%20Conventions">String/Array Conventions</a>
-<li>parent directory: <a href="#File%20Name%20Resolution">File Name Resolution</a>
-<li>parent process: <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>, <a href="#Processes">Processes</a>
-<li>parity checking: <a href="#Input%20Modes">Input Modes</a>
-<li>parsing a template string: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li>parsing numbers (in formatted input): <a href="#Parsing%20of%20Numbers">Parsing of Numbers</a>
-<li>parsing program arguments: <a href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
-<li>parsing tokens from a string: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li>passwd: <a href="#NSS%20Basics">NSS Basics</a>
-<li>password database: <a href="#User%20Database">User Database</a>
-<li><code>PATH</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li><code>pause</code> function: <a href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>
+<li>optional arguments: <a href="#Variadic Functions">Variadic Functions</a>
+<li>optional POSIX features: <a href="#System Options">System Options</a>
+<li>orientation, stream: <a href="#Streams and I18N">Streams and I18N</a>, <a href="#Opening Streams">Opening Streams</a>
+<li>orphaned process group: <a href="#Orphaned Process Groups">Orphaned Process Groups</a>
+<li>out-of-band data: <a href="#Out-of-Band Data">Out-of-Band Data</a>
+<li>output conversions, for <code>printf</code>: <a href="#Table of Output Conversions">Table of Output Conversions</a>
+<li>output possible signal: <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>
+<li>overflow exception: <a href="#FP Exceptions">FP Exceptions</a>
+<li>owner of a file: <a href="#File Owner">File Owner</a>
+<li>packet: <a href="#Socket Concepts">Socket Concepts</a>
+<li>page boundary: <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>
+<li>page fault: <a href="#Memory Concepts">Memory Concepts</a>
+<li>page fault, copy-on-write: <a href="#Locked Memory Details">Locked Memory Details</a>
+<li>page frame: <a href="#Memory Concepts">Memory Concepts</a>
+<li>page, memory: <a href="#Memory Subsystem">Memory Subsystem</a>
+<li>page, virtual memory: <a href="#Memory Concepts">Memory Concepts</a>
+<li>paging: <a href="#Locking Pages">Locking Pages</a>, <a href="#Memory Concepts">Memory Concepts</a>
+<li>parameter promotion: <a href="#String%2fArray Conventions">String/Array Conventions</a>
+<li>parent directory: <a href="#File Name Resolution">File Name Resolution</a>
+<li>parent process: <a href="#Process Creation Concepts">Process Creation Concepts</a>, <a href="#Processes">Processes</a>
+<li>parity checking: <a href="#Input Modes">Input Modes</a>
+<li>parsing a template string: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li>parsing numbers (in formatted input): <a href="#Parsing of Numbers">Parsing of Numbers</a>
+<li>parsing program arguments: <a href="#Parsing Program Arguments">Parsing Program Arguments</a>
+<li>parsing tokens from a string: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li>passwd: <a href="#NSS Basics">NSS Basics</a>
+<li>password database: <a href="#User Database">User Database</a>
+<li><code>PATH</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li><code>pause</code> function: <a href="#Waiting for a Signal">Waiting for a Signal</a>
 <li>peeking at input: <a href="#Unreading">Unreading</a>
-<li>pending signals: <a href="#Delivery%20of%20Signal">Delivery of Signal</a>
-<li>pending signals, checking for: <a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>
-<li>period of time: <a href="#Time%20Basics">Time Basics</a>
-<li>permission to access a file: <a href="#Access%20Permission">Access Permission</a>
-<li>persona: <a href="#Process%20Persona">Process Persona</a>
-<li>physical address: <a href="#Memory%20Subsystem">Memory Subsystem</a>
-<li>physical memory: <a href="#Memory%20Subsystem">Memory Subsystem</a>
-<li>pi (trigonometric constant): <a href="#Trig%20Functions">Trig Functions</a>
-<li>pipe: <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>
-<li>pipe signal: <a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li>pipe to a subprocess: <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>
+<li>pending signals: <a href="#Delivery of Signal">Delivery of Signal</a>
+<li>pending signals, checking for: <a href="#Checking for Pending Signals">Checking for Pending Signals</a>
+<li>period of time: <a href="#Time Basics">Time Basics</a>
+<li>permission to access a file: <a href="#Access Permission">Access Permission</a>
+<li>persona: <a href="#Process Persona">Process Persona</a>
+<li>physical address: <a href="#Memory Subsystem">Memory Subsystem</a>
+<li>physical memory: <a href="#Memory Subsystem">Memory Subsystem</a>
+<li>pi (trigonometric constant): <a href="#Trig Functions">Trig Functions</a>
+<li>pipe: <a href="#Pipes and FIFOs">Pipes and FIFOs</a>
+<li>pipe signal: <a href="#Operation Error Signals">Operation Error Signals</a>
+<li>pipe to a subprocess: <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>
 <li>port number: <a href="#Ports">Ports</a>
-<li>positioning a file descriptor: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li>positioning a stream: <a href="#File%20Positioning">File Positioning</a>
-<li>positive difference: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
+<li>positioning a file descriptor: <a href="#File Position Primitive">File Position Primitive</a>
+<li>positioning a stream: <a href="#File Positioning">File Positioning</a>
+<li>positive difference: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
 <li>POSIX: <a href="#POSIX">POSIX</a>
-<li>POSIX capacity limits: <a href="#General%20Limits">General Limits</a>
-<li>POSIX optional features: <a href="#System%20Options">System Options</a>
+<li>POSIX capacity limits: <a href="#General Limits">General Limits</a>
+<li>POSIX optional features: <a href="#System Options">System Options</a>
 <li>POSIX.1: <a href="#POSIX">POSIX</a>
 <li>POSIX.2: <a href="#POSIX">POSIX</a>
-<li>power functions: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li>precision (of floating point number): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>precision (<code>printf</code>): <a href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>
-<li>predicates on arrays: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li>predicates on characters: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>predicates on strings: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li>preemptive scheduling: <a href="#Absolute%20Priority">Absolute Priority</a>
-<li>primitives, interrupting: <a href="#Interrupted%20Primitives">Interrupted Primitives</a>
-<li>printing character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
+<li>power functions: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li>precision (of floating point number): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>precision (<code>printf</code>): <a href="#Output Conversion Syntax">Output Conversion Syntax</a>
+<li>predicates on arrays: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li>predicates on characters: <a href="#Classification of Characters">Classification of Characters</a>
+<li>predicates on strings: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li>preemptive scheduling: <a href="#Absolute Priority">Absolute Priority</a>
+<li>primitives, interrupting: <a href="#Interrupted Primitives">Interrupted Primitives</a>
+<li>printing character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
 <li>priority of a process: <a href="#Priority">Priority</a>
-<li>priority, absolute: <a href="#Absolute%20Priority">Absolute Priority</a>
-<li>process: <a href="#Processes">Processes</a>, <a href="#Program%20Basics">Program Basics</a>
-<li>process completion: <a href="#Process%20Completion">Process Completion</a>
-<li>process group functions: <a href="#Functions%20for%20Job%20Control">Functions for Job Control</a>
-<li>process group ID: <a href="#Launching%20Jobs">Launching Jobs</a>
-<li>process group leader: <a href="#Launching%20Jobs">Launching Jobs</a>
-<li>process groups: <a href="#Job%20Control">Job Control</a>
-<li>process ID: <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>
-<li>process image: <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>
-<li>process lifetime: <a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>
+<li>priority, absolute: <a href="#Absolute Priority">Absolute Priority</a>
+<li>process: <a href="#Processes">Processes</a>, <a href="#Program Basics">Program Basics</a>
+<li>process completion: <a href="#Process Completion">Process Completion</a>
+<li>process group functions: <a href="#Functions for Job Control">Functions for Job Control</a>
+<li>process group ID: <a href="#Launching Jobs">Launching Jobs</a>
+<li>process group leader: <a href="#Launching Jobs">Launching Jobs</a>
+<li>process groups: <a href="#Job Control">Job Control</a>
+<li>process ID: <a href="#Process Creation Concepts">Process Creation Concepts</a>
+<li>process image: <a href="#Process Creation Concepts">Process Creation Concepts</a>
+<li>process lifetime: <a href="#Process Creation Concepts">Process Creation Concepts</a>
 <li>process priority: <a href="#Priority">Priority</a>
-<li>process signal mask: <a href="#Process%20Signal%20Mask">Process Signal Mask</a>
-<li>process termination: <a href="#Program%20Termination">Program Termination</a>
-<li>processor time: <a href="#Processor%20Time">Processor Time</a>, <a href="#Time%20Basics">Time Basics</a>
-<li>profiling alarm signal: <a href="#Alarm%20Signals">Alarm Signals</a>
-<li>profiling timer: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>program: <a href="#Program%20Basics">Program Basics</a>
-<li>program argument syntax: <a href="#Argument%20Syntax">Argument Syntax</a>
-<li>program arguments: <a href="#Program%20Arguments">Program Arguments</a>
-<li>program arguments, parsing: <a href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
-<li>program error signals: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li>program name: <a href="#Error%20Messages">Error Messages</a>
-<li>program startup: <a href="#Program%20Arguments">Program Arguments</a>
-<li>program termination: <a href="#Program%20Termination">Program Termination</a>
-<li>program termination signals: <a href="#Termination%20Signals">Termination Signals</a>
-<li>programming your own streams: <a href="#Custom%20Streams">Custom Streams</a>
-<li>project complex numbers: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li>protocol (of socket): <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>protocol family: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>protocols: <a href="#NSS%20Basics">NSS Basics</a>
-<li>protocols database: <a href="#Protocols%20Database">Protocols Database</a>
-<li>prototypes for variadic functions: <a href="#Variadic%20Prototypes">Variadic Prototypes</a>
-<li>pseudo-random numbers: <a href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>
+<li>process signal mask: <a href="#Process Signal Mask">Process Signal Mask</a>
+<li>process termination: <a href="#Program Termination">Program Termination</a>
+<li>processor time: <a href="#Processor Time">Processor Time</a>, <a href="#Time Basics">Time Basics</a>
+<li>profiling alarm signal: <a href="#Alarm Signals">Alarm Signals</a>
+<li>profiling timer: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>program: <a href="#Program Basics">Program Basics</a>
+<li>program argument syntax: <a href="#Argument Syntax">Argument Syntax</a>
+<li>program arguments: <a href="#Program Arguments">Program Arguments</a>
+<li>program arguments, parsing: <a href="#Parsing Program Arguments">Parsing Program Arguments</a>
+<li>program error signals: <a href="#Program Error Signals">Program Error Signals</a>
+<li>program name: <a href="#Error Messages">Error Messages</a>
+<li>program startup: <a href="#Program Arguments">Program Arguments</a>
+<li>program termination: <a href="#Program Termination">Program Termination</a>
+<li>program termination signals: <a href="#Termination Signals">Termination Signals</a>
+<li>programming your own streams: <a href="#Custom Streams">Custom Streams</a>
+<li>project complex numbers: <a href="#Operations on Complex">Operations on Complex</a>
+<li>protocol (of socket): <a href="#Socket Concepts">Socket Concepts</a>
+<li>protocol family: <a href="#Socket Concepts">Socket Concepts</a>
+<li>protocols: <a href="#NSS Basics">NSS Basics</a>
+<li>protocols database: <a href="#Protocols Database">Protocols Database</a>
+<li>prototypes for variadic functions: <a href="#Variadic Prototypes">Variadic Prototypes</a>
+<li>pseudo-random numbers: <a href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>
 <li>pseudo-terminals: <a href="#Pseudo-Terminals">Pseudo-Terminals</a>
-<li>punctuation character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
+<li>punctuation character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
 <li>pushing input back: <a href="#Unreading">Unreading</a>
-<li>quick sort function (for arrays): <a href="#Array%20Sort%20Function">Array Sort Function</a>
-<li>QUIT character: <a href="#Signal%20Characters">Signal Characters</a>
-<li>quit signal: <a href="#Termination%20Signals">Termination Signals</a>
-<li>quote removal: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>race conditions, relating to job control: <a href="#Launching%20Jobs">Launching Jobs</a>
-<li>race conditions, relating to signals: <a href="#Signals%20in%20Handler">Signals in Handler</a>
-<li>radix (of floating point number): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>raising signals: <a href="#Generating%20Signals">Generating Signals</a>
-<li>random numbers: <a href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>
-<li>random-access files: <a href="#File%20Position">File Position</a>
-<li>range error: <a href="#Math%20Error%20Reporting">Math Error Reporting</a>
-<li>range of integer type: <a href="#Range%20of%20Type">Range of Type</a>
-<li>read lock: <a href="#File%20Locks">File Locks</a>
-<li>reading from a directory: <a href="#Accessing%20Directories">Accessing Directories</a>
-<li>reading from a file descriptor: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li>reading from a socket: <a href="#Transferring%20Data">Transferring Data</a>
-<li>reading from a stream, by blocks: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li>reading from a stream, by characters: <a href="#Character%20Input">Character Input</a>
-<li>reading from a stream, formatted: <a href="#Formatted%20Input">Formatted Input</a>
-<li>ready to run: <a href="#Absolute%20Priority">Absolute Priority</a>
-<li>real group ID: <a href="#Process%20Persona">Process Persona</a>
-<li>real user ID: <a href="#Process%20Persona">Process Persona</a>
-<li>real-time timer: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>realtime CPU scheduling: <a href="#Absolute%20Priority">Absolute Priority</a>
-<li>realtime processing: <a href="#Why%20Lock%20Pages">Why Lock Pages</a>
-<li>realtime scheduling: <a href="#Realtime%20Scheduling">Realtime Scheduling</a>
-<li>receiving datagrams: <a href="#Receiving%20Datagrams">Receiving Datagrams</a>
-<li>record locking: <a href="#File%20Locks">File Locks</a>
-<li>redirecting input and output: <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>
+<li>quick sort function (for arrays): <a href="#Array Sort Function">Array Sort Function</a>
+<li>QUIT character: <a href="#Signal Characters">Signal Characters</a>
+<li>quit signal: <a href="#Termination Signals">Termination Signals</a>
+<li>quote removal: <a href="#Expansion Stages">Expansion Stages</a>
+<li>race conditions, relating to job control: <a href="#Launching Jobs">Launching Jobs</a>
+<li>race conditions, relating to signals: <a href="#Signals in Handler">Signals in Handler</a>
+<li>radix (of floating point number): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>raising signals: <a href="#Generating Signals">Generating Signals</a>
+<li>random numbers: <a href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>
+<li>random-access files: <a href="#File Position">File Position</a>
+<li>range error: <a href="#Math Error Reporting">Math Error Reporting</a>
+<li>range of integer type: <a href="#Range of Type">Range of Type</a>
+<li>read lock: <a href="#File Locks">File Locks</a>
+<li>reading from a directory: <a href="#Accessing Directories">Accessing Directories</a>
+<li>reading from a file descriptor: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li>reading from a socket: <a href="#Transferring Data">Transferring Data</a>
+<li>reading from a stream, by blocks: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li>reading from a stream, by characters: <a href="#Character Input">Character Input</a>
+<li>reading from a stream, formatted: <a href="#Formatted Input">Formatted Input</a>
+<li>ready to run: <a href="#Absolute Priority">Absolute Priority</a>
+<li>real group ID: <a href="#Process Persona">Process Persona</a>
+<li>real user ID: <a href="#Process Persona">Process Persona</a>
+<li>real-time timer: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>realtime CPU scheduling: <a href="#Absolute Priority">Absolute Priority</a>
+<li>realtime processing: <a href="#Why Lock Pages">Why Lock Pages</a>
+<li>realtime scheduling: <a href="#Realtime Scheduling">Realtime Scheduling</a>
+<li>receiving datagrams: <a href="#Receiving Datagrams">Receiving Datagrams</a>
+<li>record locking: <a href="#File Locks">File Locks</a>
+<li>redirecting input and output: <a href="#Duplicating Descriptors">Duplicating Descriptors</a>
 <li>reentrant functions: <a href="#Nonreentrancy">Nonreentrancy</a>
-<li>reentrant NSS functions: <a href="#NSS%20Module%20Names">NSS Module Names</a>
-<li>relative file name: <a href="#File%20Name%20Resolution">File Name Resolution</a>
-<li>removal of quotes: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>removing a file: <a href="#Deleting%20Files">Deleting Files</a>
-<li>removing macros that shadow functions: <a href="#Macro%20Definitions">Macro Definitions</a>
-<li>renaming a file: <a href="#Renaming%20Files">Renaming Files</a>
-<li>reporting bugs: <a href="#Reporting%20Bugs">Reporting Bugs</a>
-<li>reporting errors: <a href="#Error%20Reporting">Error Reporting</a>
-<li>REPRINT character: <a href="#Editing%20Characters">Editing Characters</a>
-<li>reserved names: <a href="#Reserved%20Names">Reserved Names</a>
-<li>resource limits: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li>restarting interrupted primitives: <a href="#Interrupted%20Primitives">Interrupted Primitives</a>
+<li>reentrant NSS functions: <a href="#NSS Module Names">NSS Module Names</a>
+<li>relative file name: <a href="#File Name Resolution">File Name Resolution</a>
+<li>removal of quotes: <a href="#Expansion Stages">Expansion Stages</a>
+<li>removing a file: <a href="#Deleting Files">Deleting Files</a>
+<li>removing macros that shadow functions: <a href="#Macro Definitions">Macro Definitions</a>
+<li>renaming a file: <a href="#Renaming Files">Renaming Files</a>
+<li>reporting bugs: <a href="#Reporting Bugs">Reporting Bugs</a>
+<li>reporting errors: <a href="#Error Reporting">Error Reporting</a>
+<li>REPRINT character: <a href="#Editing Characters">Editing Characters</a>
+<li>reserved names: <a href="#Reserved Names">Reserved Names</a>
+<li>resource limits: <a href="#Limits on Resources">Limits on Resources</a>
+<li>restarting interrupted primitives: <a href="#Interrupted Primitives">Interrupted Primitives</a>
 <li>restrictions on signal handler functions: <a href="#Nonreentrancy">Nonreentrancy</a>
-<li>root directory: <a href="#File%20Name%20Resolution">File Name Resolution</a>
-<li>Rot13: <a href="#Trivial%20Encryption">Trivial Encryption</a>
-<li>rpc: <a href="#NSS%20Basics">NSS Basics</a>
-<li>runnable process: <a href="#Absolute%20Priority">Absolute Priority</a>
-<li>running a command: <a href="#Running%20a%20Command">Running a Command</a>
-<li>saved set-group-ID: <a href="#How%20Change%20Persona">How Change Persona</a>
-<li>saved set-user-ID: <a href="#How%20Change%20Persona">How Change Persona</a>
-<li>scanning the group list: <a href="#Scanning%20All%20Groups">Scanning All Groups</a>
-<li>scanning the user list: <a href="#Scanning%20All%20Users">Scanning All Users</a>
+<li>root directory: <a href="#File Name Resolution">File Name Resolution</a>
+<li>Rot13: <a href="#Trivial Encryption">Trivial Encryption</a>
+<li>rpc: <a href="#NSS Basics">NSS Basics</a>
+<li>runnable process: <a href="#Absolute Priority">Absolute Priority</a>
+<li>running a command: <a href="#Running a Command">Running a Command</a>
+<li>saved set-group-ID: <a href="#How Change Persona">How Change Persona</a>
+<li>saved set-user-ID: <a href="#How Change Persona">How Change Persona</a>
+<li>scanning the group list: <a href="#Scanning All Groups">Scanning All Groups</a>
+<li>scanning the user list: <a href="#Scanning All Users">Scanning All Users</a>
 <li>scatter-gather: <a href="#Scatter-Gather">Scatter-Gather</a>
-<li>scheduling, traditional: <a href="#Traditional%20Scheduling">Traditional Scheduling</a>
-<li>search function (for arrays): <a href="#Array%20Search%20Function">Array Search Function</a>
-<li>search functions (for strings): <a href="#Search%20Functions">Search Functions</a>
-<li>seed (for random numbers): <a href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>
-<li>seeking on a file descriptor: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li>seeking on a stream: <a href="#File%20Positioning">File Positioning</a>
-<li>segmentation violation: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li>sending a datagram: <a href="#Sending%20Datagrams">Sending Datagrams</a>
-<li>sending signals: <a href="#Generating%20Signals">Generating Signals</a>
-<li>sequential-access files: <a href="#File%20Position">File Position</a>
+<li>scheduling, traditional: <a href="#Traditional Scheduling">Traditional Scheduling</a>
+<li>search function (for arrays): <a href="#Array Search Function">Array Search Function</a>
+<li>search functions (for strings): <a href="#Search Functions">Search Functions</a>
+<li>seed (for random numbers): <a href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>
+<li>seeking on a file descriptor: <a href="#File Position Primitive">File Position Primitive</a>
+<li>seeking on a stream: <a href="#File Positioning">File Positioning</a>
+<li>segmentation violation: <a href="#Program Error Signals">Program Error Signals</a>
+<li>sending a datagram: <a href="#Sending Datagrams">Sending Datagrams</a>
+<li>sending signals: <a href="#Generating Signals">Generating Signals</a>
+<li>sequential-access files: <a href="#File Position">File Position</a>
 <li>server: <a href="#Connections">Connections</a>
-<li>services: <a href="#NSS%20Basics">NSS Basics</a>
-<li>services database: <a href="#Services%20Database">Services Database</a>
-<li>session: <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>, <a href="#Job%20Control">Job Control</a>
-<li>session leader: <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>
-<li>setting an alarm: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>setuid</code> programs: <a href="#How%20Change%20Persona">How Change Persona</a>
-<li>setuid programs and file access: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li>severity class: <a href="#Adding%20Severity%20Classes">Adding Severity Classes</a>, <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li>sgettext: <a href="#GUI%20program%20problems">GUI program problems</a>
-<li>shadow: <a href="#NSS%20Basics">NSS Basics</a>
-<li>shadowing functions with macros: <a href="#Macro%20Definitions">Macro Definitions</a>
-<li>shared lock: <a href="#File%20Locks">File Locks</a>
-<li>shared memory: <a href="#Memory%20Subsystem">Memory Subsystem</a>
-<li>shell: <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>
-<li>shift state: <a href="#Keeping%20the%20state">Keeping the state</a>
-<li>Shift_JIS: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>shrinking objects: <a href="#Growing%20Objects">Growing Objects</a>
-<li>shutting down a socket: <a href="#Closing%20a%20Socket">Closing a Socket</a>
-<li><code>sigaction</code> flags: <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>
-<li><code>sigaction</code> function: <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>
-<li><code>SIGCHLD</code>, handling of: <a href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>
-<li>sign (of floating point number): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li>signal: <a href="#Signal%20Handling">Signal Handling</a>, <a href="#FP%20Exceptions">FP Exceptions</a>
-<li>signal action: <a href="#Delivery%20of%20Signal">Delivery of Signal</a>
-<li>signal actions: <a href="#Signal%20Actions">Signal Actions</a>
-<li>signal flags: <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>
-<li><code>signal</code> function: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li>signal handler function: <a href="#Defining%20Handlers">Defining Handlers</a>
-<li>signal mask: <a href="#Process%20Signal%20Mask">Process Signal Mask</a>
-<li>signal messages: <a href="#Signal%20Messages">Signal Messages</a>
-<li>signal names: <a href="#Standard%20Signals">Standard Signals</a>
-<li>signal number: <a href="#Standard%20Signals">Standard Signals</a>
-<li>signal set: <a href="#Signal%20Sets">Signal Sets</a>
-<li>signals, generating: <a href="#Generating%20Signals">Generating Signals</a>
+<li>services: <a href="#NSS Basics">NSS Basics</a>
+<li>services database: <a href="#Services Database">Services Database</a>
+<li>session: <a href="#Concepts of Job Control">Concepts of Job Control</a>, <a href="#Job Control">Job Control</a>
+<li>session leader: <a href="#Concepts of Job Control">Concepts of Job Control</a>
+<li>setting an alarm: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>setuid</code> programs: <a href="#How Change Persona">How Change Persona</a>
+<li>setuid programs and file access: <a href="#Testing File Access">Testing File Access</a>
+<li>severity class: <a href="#Adding Severity Classes">Adding Severity Classes</a>, <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li>sgettext: <a href="#GUI program problems">GUI program problems</a>
+<li>shadow: <a href="#NSS Basics">NSS Basics</a>
+<li>shadowing functions with macros: <a href="#Macro Definitions">Macro Definitions</a>
+<li>shared lock: <a href="#File Locks">File Locks</a>
+<li>shared memory: <a href="#Memory Subsystem">Memory Subsystem</a>
+<li>shell: <a href="#Concepts of Job Control">Concepts of Job Control</a>
+<li>shift state: <a href="#Keeping the state">Keeping the state</a>
+<li>Shift_JIS: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>shrinking objects: <a href="#Growing Objects">Growing Objects</a>
+<li>shutting down a socket: <a href="#Closing a Socket">Closing a Socket</a>
+<li><code>sigaction</code> flags: <a href="#Flags for Sigaction">Flags for Sigaction</a>
+<li><code>sigaction</code> function: <a href="#Advanced Signal Handling">Advanced Signal Handling</a>
+<li><code>SIGCHLD</code>, handling of: <a href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>
+<li>sign (of floating point number): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li>signal: <a href="#Signal Handling">Signal Handling</a>, <a href="#FP Exceptions">FP Exceptions</a>
+<li>signal action: <a href="#Delivery of Signal">Delivery of Signal</a>
+<li>signal actions: <a href="#Signal Actions">Signal Actions</a>
+<li>signal flags: <a href="#Flags for Sigaction">Flags for Sigaction</a>
+<li><code>signal</code> function: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li>signal handler function: <a href="#Defining Handlers">Defining Handlers</a>
+<li>signal mask: <a href="#Process Signal Mask">Process Signal Mask</a>
+<li>signal messages: <a href="#Signal Messages">Signal Messages</a>
+<li>signal names: <a href="#Standard Signals">Standard Signals</a>
+<li>signal number: <a href="#Standard Signals">Standard Signals</a>
+<li>signal set: <a href="#Signal Sets">Signal Sets</a>
+<li>signals, generating: <a href="#Generating Signals">Generating Signals</a>
 <li>signedness: <a href="#Integers">Integers</a>
-<li>significand (of floating point number): <a href="#Floating%20Point%20Concepts">Floating Point Concepts</a>
-<li><code>SIGTTIN</code>, from background job: <a href="#Access%20to%20the%20Terminal">Access to the Terminal</a>
-<li><code>SIGTTOU</code>, from background job: <a href="#Access%20to%20the%20Terminal">Access to the Terminal</a>
-<li>simple time: <a href="#Calendar%20Time">Calendar Time</a>
-<li>single-byte string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>size of string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>SJIS: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
+<li>significand (of floating point number): <a href="#Floating Point Concepts">Floating Point Concepts</a>
+<li><code>SIGTTIN</code>, from background job: <a href="#Access to the Terminal">Access to the Terminal</a>
+<li><code>SIGTTOU</code>, from background job: <a href="#Access to the Terminal">Access to the Terminal</a>
+<li>simple time: <a href="#Calendar Time">Calendar Time</a>
+<li>single-byte string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>size of string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>SJIS: <a href="#Extended Char Intro">Extended Char Intro</a>
 <li>socket: <a href="#Sockets">Sockets</a>
-<li>socket address (name) binding: <a href="#Socket%20Addresses">Socket Addresses</a>
-<li>socket domain: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>socket namespace: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>socket option level: <a href="#Socket%20Options">Socket Options</a>
-<li>socket options: <a href="#Socket%20Options">Socket Options</a>
-<li>socket pair: <a href="#Socket%20Pairs">Socket Pairs</a>
-<li>socket protocol: <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>socket shutdown: <a href="#Closing%20a%20Socket">Closing a Socket</a>
+<li>socket address (name) binding: <a href="#Socket Addresses">Socket Addresses</a>
+<li>socket domain: <a href="#Socket Concepts">Socket Concepts</a>
+<li>socket namespace: <a href="#Socket Concepts">Socket Concepts</a>
+<li>socket option level: <a href="#Socket Options">Socket Options</a>
+<li>socket options: <a href="#Socket Options">Socket Options</a>
+<li>socket pair: <a href="#Socket Pairs">Socket Pairs</a>
+<li>socket protocol: <a href="#Socket Concepts">Socket Concepts</a>
+<li>socket shutdown: <a href="#Closing a Socket">Closing a Socket</a>
 <li>socket, client actions: <a href="#Connecting">Connecting</a>
-<li>socket, closing: <a href="#Closing%20a%20Socket">Closing a Socket</a>
+<li>socket, closing: <a href="#Closing a Socket">Closing a Socket</a>
 <li>socket, connecting: <a href="#Connecting">Connecting</a>
-<li>socket, creating: <a href="#Creating%20a%20Socket">Creating a Socket</a>
+<li>socket, creating: <a href="#Creating a Socket">Creating a Socket</a>
 <li>socket, initiating a connection: <a href="#Connecting">Connecting</a>
-<li>sockets, accepting connections: <a href="#Accepting%20Connections">Accepting Connections</a>
+<li>sockets, accepting connections: <a href="#Accepting Connections">Accepting Connections</a>
 <li>sockets, listening: <a href="#Listening">Listening</a>
 <li>sockets, server actions: <a href="#Listening">Listening</a>
-<li>soft limit: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li>soft link: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li>sort function (for arrays): <a href="#Array%20Sort%20Function">Array Sort Function</a>
-<li>sparse files: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li>special files: <a href="#Making%20Special%20Files">Making Special Files</a>
-<li>special functions: <a href="#Special%20Functions">Special Functions</a>
-<li>specified action (for a signal): <a href="#Delivery%20of%20Signal">Delivery of Signal</a>
-<li>speed of execution: <a href="#Why%20Lock%20Pages">Why Lock Pages</a>
-<li>square root function: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li>stable sorting: <a href="#Array%20Sort%20Function">Array Sort Function</a>
-<li>standard dot notation, for Internet addresses: <a href="#Abstract%20Host%20Addresses">Abstract Host Addresses</a>
-<li>standard environment variables: <a href="#Standard%20Environment">Standard Environment</a>
-<li>standard error file descriptor: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li>standard error stream: <a href="#Standard%20Streams">Standard Streams</a>
-<li>standard file descriptors: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li>standard input file descriptor: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li>standard input stream: <a href="#Standard%20Streams">Standard Streams</a>
-<li>standard output file descriptor: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li>standard output stream: <a href="#Standard%20Streams">Standard Streams</a>
-<li>standard streams: <a href="#Standard%20Streams">Standard Streams</a>
-<li>standards: <a href="#Standards%20and%20Portability">Standards and Portability</a>
-<li>START character: <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>
-<li>startup of program: <a href="#Program%20Arguments">Program Arguments</a>
-<li>stateful: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>, <a href="#iconv%20Examples">iconv Examples</a>, <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>, <a href="#Converting%20Strings">Converting Strings</a>, <a href="#Converting%20a%20Character">Converting a Character</a>, <a href="#Keeping%20the%20state">Keeping the state</a>
-<li>static memory allocation: <a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>
-<li>static storage class: <a href="#Memory%20Allocation%20and%20C">Memory Allocation and C</a>
-<li>STATUS character: <a href="#Other%20Special">Other Special</a>
-<li>status codes: <a href="#Error%20Reporting">Error Reporting</a>
-<li>status of a file: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li>status of obstack: <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>
-<li>sticky bit: <a href="#Permission%20Bits">Permission Bits</a>
-<li>STOP character: <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>
-<li>stop signal: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li>stopped job: <a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>
-<li>stopped jobs, continuing: <a href="#Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>
-<li>stopped jobs, detecting: <a href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>
+<li>soft limit: <a href="#Limits on Resources">Limits on Resources</a>
+<li>soft link: <a href="#Symbolic Links">Symbolic Links</a>
+<li>sort function (for arrays): <a href="#Array Sort Function">Array Sort Function</a>
+<li>sparse files: <a href="#File Position Primitive">File Position Primitive</a>
+<li>special files: <a href="#Making Special Files">Making Special Files</a>
+<li>special functions: <a href="#Special Functions">Special Functions</a>
+<li>specified action (for a signal): <a href="#Delivery of Signal">Delivery of Signal</a>
+<li>speed of execution: <a href="#Why Lock Pages">Why Lock Pages</a>
+<li>square root function: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li>stable sorting: <a href="#Array Sort Function">Array Sort Function</a>
+<li>standard dot notation, for Internet addresses: <a href="#Abstract Host Addresses">Abstract Host Addresses</a>
+<li>standard environment variables: <a href="#Standard Environment">Standard Environment</a>
+<li>standard error file descriptor: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li>standard error stream: <a href="#Standard Streams">Standard Streams</a>
+<li>standard file descriptors: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li>standard input file descriptor: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li>standard input stream: <a href="#Standard Streams">Standard Streams</a>
+<li>standard output file descriptor: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li>standard output stream: <a href="#Standard Streams">Standard Streams</a>
+<li>standard streams: <a href="#Standard Streams">Standard Streams</a>
+<li>standards: <a href="#Standards and Portability">Standards and Portability</a>
+<li>START character: <a href="#Start%2fStop Characters">Start/Stop Characters</a>
+<li>startup of program: <a href="#Program Arguments">Program Arguments</a>
+<li>stateful: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>, <a href="#iconv Examples">iconv Examples</a>, <a href="#Generic Conversion Interface">Generic Conversion Interface</a>, <a href="#Converting Strings">Converting Strings</a>, <a href="#Converting a Character">Converting a Character</a>, <a href="#Keeping the state">Keeping the state</a>
+<li>static memory allocation: <a href="#Memory Allocation and C">Memory Allocation and C</a>
+<li>static storage class: <a href="#Memory Allocation and C">Memory Allocation and C</a>
+<li>STATUS character: <a href="#Other Special">Other Special</a>
+<li>status codes: <a href="#Error Reporting">Error Reporting</a>
+<li>status of a file: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li>status of obstack: <a href="#Status of an Obstack">Status of an Obstack</a>
+<li>sticky bit: <a href="#Permission Bits">Permission Bits</a>
+<li>STOP character: <a href="#Start%2fStop Characters">Start/Stop Characters</a>
+<li>stop signal: <a href="#Job Control Signals">Job Control Signals</a>
+<li>stopped job: <a href="#Concepts of Job Control">Concepts of Job Control</a>
+<li>stopped jobs, continuing: <a href="#Continuing Stopped Jobs">Continuing Stopped Jobs</a>
+<li>stopped jobs, detecting: <a href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>
 <li>storage allocation: <a href="#Memory">Memory</a>
-<li>stream (sockets): <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>stream orientation: <a href="#Streams%20and%20I18N">Streams and I18N</a>, <a href="#Opening%20Streams">Opening Streams</a>
-<li>stream, for I/O to a string: <a href="#String%20Streams">String Streams</a>
-<li>streams and descriptors: <a href="#Stream%2fDescriptor%20Precautions">Stream/Descriptor Precautions</a>
-<li>streams, and file descriptors: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li>streams, C++: <a href="#Streams%20and%20I18N">Streams and I18N</a>
-<li>streams, standard: <a href="#Standard%20Streams">Standard Streams</a>
-<li>string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>string allocation: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>string collation functions: <a href="#Collation%20Functions">Collation Functions</a>
-<li>string comparison functions: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li>string concatenation functions: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li>string copy functions: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li>string length: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>string literal: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>string search functions: <a href="#Search%20Functions">Search Functions</a>
-<li>string stream: <a href="#String%20Streams">String Streams</a>
-<li>string vectors, null-character separated: <a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
-<li>string, representation of: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>style of communication (of a socket): <a href="#Socket%20Concepts">Socket Concepts</a>
-<li>subshell: <a href="#Initializing%20the%20Shell">Initializing the Shell</a>
-<li>substitution of variables and commands: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>successive signals: <a href="#Merged%20Signals">Merged Signals</a>
-<li>summer time: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li>SunOS: <a href="#Berkeley%20Unix">Berkeley Unix</a>
-<li>supplementary group IDs: <a href="#Process%20Persona">Process Persona</a>
-<li>SUSP character: <a href="#Signal%20Characters">Signal Characters</a>
-<li>suspend character: <a href="#Signal%20Characters">Signal Characters</a>
+<li>stream (sockets): <a href="#Socket Concepts">Socket Concepts</a>
+<li>stream orientation: <a href="#Streams and I18N">Streams and I18N</a>, <a href="#Opening Streams">Opening Streams</a>
+<li>stream, for I/O to a string: <a href="#String Streams">String Streams</a>
+<li>streams and descriptors: <a href="#Stream%2fDescriptor Precautions">Stream/Descriptor Precautions</a>
+<li>streams, and file descriptors: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li>streams, C++: <a href="#Streams and I18N">Streams and I18N</a>
+<li>streams, standard: <a href="#Standard Streams">Standard Streams</a>
+<li>string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>string allocation: <a href="#Representation of Strings">Representation of Strings</a>
+<li>string collation functions: <a href="#Collation Functions">Collation Functions</a>
+<li>string comparison functions: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li>string concatenation functions: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li>string copy functions: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li>string length: <a href="#Representation of Strings">Representation of Strings</a>
+<li>string literal: <a href="#Representation of Strings">Representation of Strings</a>
+<li>string search functions: <a href="#Search Functions">Search Functions</a>
+<li>string stream: <a href="#String Streams">String Streams</a>
+<li>string vectors, null-character separated: <a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
+<li>string, representation of: <a href="#Representation of Strings">Representation of Strings</a>
+<li>style of communication (of a socket): <a href="#Socket Concepts">Socket Concepts</a>
+<li>subshell: <a href="#Initializing the Shell">Initializing the Shell</a>
+<li>substitution of variables and commands: <a href="#Expansion Stages">Expansion Stages</a>
+<li>successive signals: <a href="#Merged Signals">Merged Signals</a>
+<li>summer time: <a href="#Broken-down Time">Broken-down Time</a>
+<li>SunOS: <a href="#Berkeley Unix">Berkeley Unix</a>
+<li>supplementary group IDs: <a href="#Process Persona">Process Persona</a>
+<li>SUSP character: <a href="#Signal Characters">Signal Characters</a>
+<li>suspend character: <a href="#Signal Characters">Signal Characters</a>
 <li>SVID: <a href="#SVID">SVID</a>
-<li>swap space: <a href="#Memory%20Concepts">Memory Concepts</a>
-<li>symbolic link: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li>symbolic link, opening: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li>synchronizing: <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>, <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>
-<li>syntax error messages, in argp: <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>
-<li>syntax, for program arguments: <a href="#Argument%20Syntax">Argument Syntax</a>
-<li>syntax, for reading numbers: <a href="#Parsing%20of%20Numbers">Parsing of Numbers</a>
-<li>sysconf: <a href="#Processor%20Resources">Processor Resources</a>, <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>
-<li>system call: <a href="#System%20Calls">System Calls</a>
-<li>system call number: <a href="#System%20Calls">System Calls</a>
+<li>swap space: <a href="#Memory Concepts">Memory Concepts</a>
+<li>symbolic link: <a href="#Symbolic Links">Symbolic Links</a>
+<li>symbolic link, opening: <a href="#Open-time Flags">Open-time Flags</a>
+<li>synchronizing: <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>, <a href="#Synchronizing I%2fO">Synchronizing I/O</a>
+<li>syntax error messages, in argp: <a href="#Argp Helper Functions">Argp Helper Functions</a>
+<li>syntax, for program arguments: <a href="#Argument Syntax">Argument Syntax</a>
+<li>syntax, for reading numbers: <a href="#Parsing of Numbers">Parsing of Numbers</a>
+<li>sysconf: <a href="#Processor Resources">Processor Resources</a>, <a href="#Query Memory Parameters">Query Memory Parameters</a>
+<li>system call: <a href="#System Calls">System Calls</a>
+<li>system call number: <a href="#System Calls">System Calls</a>
 <li>System V Unix: <a href="#SVID">SVID</a>
-<li>TCP (Internet protocol): <a href="#Protocols%20Database">Protocols Database</a>
-<li>template, for <code>printf</code>: <a href="#Formatted%20Output">Formatted Output</a>
-<li>template, for <code>scanf</code>: <a href="#Formatted%20Input">Formatted Input</a>
-<li><code>TERM</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>terminal flow control: <a href="#Line%20Control">Line Control</a>
-<li>terminal identification: <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>
-<li>terminal input queue: <a href="#I%2fO%20Queues">I/O Queues</a>
-<li>terminal input queue, clearing: <a href="#Line%20Control">Line Control</a>
-<li>terminal input signal: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li>terminal line control functions: <a href="#Line%20Control">Line Control</a>
-<li>terminal line speed: <a href="#Line%20Speed">Line Speed</a>
-<li>terminal mode data types: <a href="#Mode%20Data%20Types">Mode Data Types</a>
-<li>terminal mode functions: <a href="#Mode%20Functions">Mode Functions</a>
-<li>terminal modes, BSD: <a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>
-<li>terminal output queue: <a href="#I%2fO%20Queues">I/O Queues</a>
-<li>terminal output queue, flushing: <a href="#Line%20Control">Line Control</a>
-<li>terminal output signal: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li>terminated jobs, detecting: <a href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>
-<li>termination signal: <a href="#Termination%20Signals">Termination Signals</a>
-<li>testing access permission: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li>testing exit status of child process: <a href="#Process%20Completion">Process Completion</a>
-<li>text stream: <a href="#Binary%20Streams">Binary Streams</a>
-<li>thrashing: <a href="#Memory%20Subsystem">Memory Subsystem</a>
-<li>thread of control: <a href="#Program%20Basics">Program Basics</a>
-<li>threads: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li>ticks, clock: <a href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>
-<li>tilde expansion: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>time: <a href="#Time%20Basics">Time Basics</a>
-<li>TIME termios slot: <a href="#Noncanonical%20Input">Noncanonical Input</a>
-<li>time zone: <a href="#TZ%20Variable">TZ Variable</a>
-<li>time zone database: <a href="#TZ%20Variable">TZ Variable</a>
-<li>time, elapsed: <a href="#Time%20Basics">Time Basics</a>
-<li>time, high precision: <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li>timer, profiling: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>timer, real-time: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>timer, virtual: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>timers, setting: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li>timespec: <a href="#Elapsed%20Time">Elapsed Time</a>
-<li>timeval: <a href="#Elapsed%20Time">Elapsed Time</a>
-<li>timing error in signal handling: <a href="#Remembering%20a%20Signal">Remembering a Signal</a>
-<li>TMPDIR environment variable: <a href="#Temporary%20Files">Temporary Files</a>
-<li>tokenizing strings: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li>tools, for installing library: <a href="#Tools%20for%20Compilation">Tools for Compilation</a>
-<li>transmitting datagrams: <a href="#Sending%20Datagrams">Sending Datagrams</a>
-<li>tree, directory: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li>triangulation: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li>trigonometric functions: <a href="#Trig%20Functions">Trig Functions</a>
-<li>type measurements, floating: <a href="#Floating%20Type%20Macros">Floating Type Macros</a>
-<li>type measurements, integer: <a href="#Width%20of%20Type">Width of Type</a>
-<li>type modifier character (<code>printf</code>): <a href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>
-<li>type modifier character (<code>scanf</code>): <a href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>
-<li>typeahead buffer: <a href="#I%2fO%20Queues">I/O Queues</a>
-<li><code>TZ</code> environment variable: <a href="#Standard%20Environment">Standard Environment</a>
-<li>UCS-2: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>UCS-4: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>ulps: <a href="#Errors%20in%20Math%20Functions">Errors in Math Functions</a>
-<li>umask: <a href="#Setting%20Permissions">Setting Permissions</a>
-<li>unbuffered stream: <a href="#Buffering%20Concepts">Buffering Concepts</a>
-<li>unconstrained memory allocation: <a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
-<li>undefining macros that shadow functions: <a href="#Macro%20Definitions">Macro Definitions</a>
-<li>underflow exception: <a href="#FP%20Exceptions">FP Exceptions</a>
-<li>Unicode: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>Unix, Berkeley: <a href="#Berkeley%20Unix">Berkeley Unix</a>
+<li>TCP (Internet protocol): <a href="#Protocols Database">Protocols Database</a>
+<li>template, for <code>printf</code>: <a href="#Formatted Output">Formatted Output</a>
+<li>template, for <code>scanf</code>: <a href="#Formatted Input">Formatted Input</a>
+<li><code>TERM</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>terminal flow control: <a href="#Line Control">Line Control</a>
+<li>terminal identification: <a href="#Is It a Terminal">Is It a Terminal</a>
+<li>terminal input queue: <a href="#I%2fO Queues">I/O Queues</a>
+<li>terminal input queue, clearing: <a href="#Line Control">Line Control</a>
+<li>terminal input signal: <a href="#Job Control Signals">Job Control Signals</a>
+<li>terminal line control functions: <a href="#Line Control">Line Control</a>
+<li>terminal line speed: <a href="#Line Speed">Line Speed</a>
+<li>terminal mode data types: <a href="#Mode Data Types">Mode Data Types</a>
+<li>terminal mode functions: <a href="#Mode Functions">Mode Functions</a>
+<li>terminal modes, BSD: <a href="#BSD Terminal Modes">BSD Terminal Modes</a>
+<li>terminal output queue: <a href="#I%2fO Queues">I/O Queues</a>
+<li>terminal output queue, flushing: <a href="#Line Control">Line Control</a>
+<li>terminal output signal: <a href="#Job Control Signals">Job Control Signals</a>
+<li>terminated jobs, detecting: <a href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>
+<li>termination signal: <a href="#Termination Signals">Termination Signals</a>
+<li>testing access permission: <a href="#Testing File Access">Testing File Access</a>
+<li>testing exit status of child process: <a href="#Process Completion">Process Completion</a>
+<li>text stream: <a href="#Binary Streams">Binary Streams</a>
+<li>thrashing: <a href="#Memory Subsystem">Memory Subsystem</a>
+<li>thread of control: <a href="#Program Basics">Program Basics</a>
+<li>threads: <a href="#Streams and Threads">Streams and Threads</a>
+<li>ticks, clock: <a href="#Processor And CPU Time">Processor And CPU Time</a>
+<li>tilde expansion: <a href="#Expansion Stages">Expansion Stages</a>
+<li>time: <a href="#Time Basics">Time Basics</a>
+<li>TIME termios slot: <a href="#Noncanonical Input">Noncanonical Input</a>
+<li>time zone: <a href="#TZ Variable">TZ Variable</a>
+<li>time zone database: <a href="#TZ Variable">TZ Variable</a>
+<li>time, elapsed: <a href="#Time Basics">Time Basics</a>
+<li>time, high precision: <a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li>timer, profiling: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>timer, real-time: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>timer, virtual: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>timers, setting: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li>timespec: <a href="#Elapsed Time">Elapsed Time</a>
+<li>timeval: <a href="#Elapsed Time">Elapsed Time</a>
+<li>timing error in signal handling: <a href="#Remembering a Signal">Remembering a Signal</a>
+<li>TMPDIR environment variable: <a href="#Temporary Files">Temporary Files</a>
+<li>tokenizing strings: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li>tools, for installing library: <a href="#Tools for Compilation">Tools for Compilation</a>
+<li>transmitting datagrams: <a href="#Sending Datagrams">Sending Datagrams</a>
+<li>tree, directory: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li>triangulation: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li>trigonometric functions: <a href="#Trig Functions">Trig Functions</a>
+<li>type measurements, floating: <a href="#Floating Type Macros">Floating Type Macros</a>
+<li>type measurements, integer: <a href="#Width of Type">Width of Type</a>
+<li>type modifier character (<code>printf</code>): <a href="#Output Conversion Syntax">Output Conversion Syntax</a>
+<li>type modifier character (<code>scanf</code>): <a href="#Input Conversion Syntax">Input Conversion Syntax</a>
+<li>typeahead buffer: <a href="#I%2fO Queues">I/O Queues</a>
+<li><code>TZ</code> environment variable: <a href="#Standard Environment">Standard Environment</a>
+<li>UCS-2: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>UCS-4: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>ulps: <a href="#Errors in Math Functions">Errors in Math Functions</a>
+<li>umask: <a href="#Setting Permissions">Setting Permissions</a>
+<li>unbuffered stream: <a href="#Buffering Concepts">Buffering Concepts</a>
+<li>unconstrained memory allocation: <a href="#Unconstrained Allocation">Unconstrained Allocation</a>
+<li>undefining macros that shadow functions: <a href="#Macro Definitions">Macro Definitions</a>
+<li>underflow exception: <a href="#FP Exceptions">FP Exceptions</a>
+<li>Unicode: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>Unix, Berkeley: <a href="#Berkeley Unix">Berkeley Unix</a>
 <li>Unix, System V: <a href="#SVID">SVID</a>
-<li>unlinking a file: <a href="#Deleting%20Files">Deleting Files</a>
-<li>unordered comparison: <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>
+<li>unlinking a file: <a href="#Deleting Files">Deleting Files</a>
+<li>unordered comparison: <a href="#FP Comparison Functions">FP Comparison Functions</a>
 <li>unreading characters: <a href="#Unreading">Unreading</a>
 <li>upgrading from libc5: <a href="#Linux">Linux</a>
-<li>upper-case character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>urgent data signal: <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>
-<li>urgent socket condition: <a href="#Out-of-Band%20Data">Out-of-Band Data</a>
-<li>usage limits: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li>usage messages, in argp: <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>
-<li>user accounting database: <a href="#User%20Accounting%20Database">User Accounting Database</a>
-<li>user database: <a href="#User%20Database">User Database</a>
-<li>user ID: <a href="#User%20and%20Group%20IDs">User and Group IDs</a>
-<li>user ID, determining: <a href="#Who%20Logged%20In">Who Logged In</a>
-<li>user name: <a href="#User%20and%20Group%20IDs">User and Group IDs</a>
-<li>user signals: <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>
-<li>usual file name errors: <a href="#File%20Name%20Errors">File Name Errors</a>
-<li>UTF-16: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>UTF-7: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>UTF-8: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>va_copy: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li>variable number of arguments: <a href="#Variadic%20Functions">Variadic Functions</a>
-<li>variable substitution: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>variable-sized arrays: <a href="#GNU%20C%20Variable-Size%20Arrays">GNU C Variable-Size Arrays</a>
-<li>variadic function argument access: <a href="#Receiving%20Arguments">Receiving Arguments</a>
-<li>variadic function prototypes: <a href="#Variadic%20Prototypes">Variadic Prototypes</a>
-<li>variadic functions: <a href="#Variadic%20Functions">Variadic Functions</a>
-<li>variadic functions, calling: <a href="#Calling%20Variadics">Calling Variadics</a>
-<li>virtual time alarm signal: <a href="#Alarm%20Signals">Alarm Signals</a>
-<li>virtual timer: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
+<li>upper-case character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>urgent data signal: <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>
+<li>urgent socket condition: <a href="#Out-of-Band Data">Out-of-Band Data</a>
+<li>usage limits: <a href="#Limits on Resources">Limits on Resources</a>
+<li>usage messages, in argp: <a href="#Argp Helper Functions">Argp Helper Functions</a>
+<li>user accounting database: <a href="#User Accounting Database">User Accounting Database</a>
+<li>user database: <a href="#User Database">User Database</a>
+<li>user ID: <a href="#User and Group IDs">User and Group IDs</a>
+<li>user ID, determining: <a href="#Who Logged In">Who Logged In</a>
+<li>user name: <a href="#User and Group IDs">User and Group IDs</a>
+<li>user signals: <a href="#Miscellaneous Signals">Miscellaneous Signals</a>
+<li>usual file name errors: <a href="#File Name Errors">File Name Errors</a>
+<li>UTF-16: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>UTF-7: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>UTF-8: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>va_copy: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li>variable number of arguments: <a href="#Variadic Functions">Variadic Functions</a>
+<li>variable substitution: <a href="#Expansion Stages">Expansion Stages</a>
+<li>variable-sized arrays: <a href="#GNU C Variable-Size Arrays">GNU C Variable-Size Arrays</a>
+<li>variadic function argument access: <a href="#Receiving Arguments">Receiving Arguments</a>
+<li>variadic function prototypes: <a href="#Variadic Prototypes">Variadic Prototypes</a>
+<li>variadic functions: <a href="#Variadic Functions">Variadic Functions</a>
+<li>variadic functions, calling: <a href="#Calling Variadics">Calling Variadics</a>
+<li>virtual time alarm signal: <a href="#Alarm Signals">Alarm Signals</a>
+<li>virtual timer: <a href="#Setting an Alarm">Setting an Alarm</a>
 <li><code>volatile</code> declarations: <a href="#Nonreentrancy">Nonreentrancy</a>
-<li>waiting for a signal: <a href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>
-<li>waiting for completion of child process: <a href="#Process%20Completion">Process Completion</a>
-<li>waiting for input or output: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li>WERASE character: <a href="#Editing%20Characters">Editing Characters</a>
-<li>whitespace character: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li>wide character: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li>wide character string: <a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li>width of integer type: <a href="#Width%20of%20Type">Width of Type</a>
-<li>wildcard expansion: <a href="#Expansion%20Stages">Expansion Stages</a>
-<li>wint_t: <a href="#String%2fArray%20Conventions">String/Array Conventions</a>
-<li>word expansion: <a href="#Word%20Expansion">Word Expansion</a>
-<li>working directory: <a href="#Working%20Directory">Working Directory</a>
-<li>write lock: <a href="#File%20Locks">File Locks</a>
-<li>writing to a file descriptor: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li>writing to a socket: <a href="#Transferring%20Data">Transferring Data</a>
-<li>writing to a stream, by blocks: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li>writing to a stream, by characters: <a href="#Simple%20Output">Simple Output</a>
-<li>writing to a stream, formatted: <a href="#Formatted%20Output">Formatted Output</a>
-<li>YP: <a href="#Host%20Identification">Host Identification</a>
-<li>YP domain name: <a href="#Host%20Identification">Host Identification</a>
-<li>zero divide: <a href="#FP%20Exceptions">FP Exceptions</a>
-</ul>
-<p><hr>
-Node:<a name="Type%20Index">Type Index</a>,
-Next:<a rel=next accesskey=n href="#Function%20Index">Function Index</a>,
-Previous:<a rel=previous accesskey=p href="#Concept%20Index">Concept Index</a>,
+<li>waiting for a signal: <a href="#Waiting for a Signal">Waiting for a Signal</a>
+<li>waiting for completion of child process: <a href="#Process Completion">Process Completion</a>
+<li>waiting for input or output: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li>WERASE character: <a href="#Editing Characters">Editing Characters</a>
+<li>whitespace character: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>, <a href="#Classification of Characters">Classification of Characters</a>
+<li>wide character: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li>wide character string: <a href="#Representation of Strings">Representation of Strings</a>
+<li>width of integer type: <a href="#Width of Type">Width of Type</a>
+<li>wildcard expansion: <a href="#Expansion Stages">Expansion Stages</a>
+<li>wint_t: <a href="#String%2fArray Conventions">String/Array Conventions</a>
+<li>word expansion: <a href="#Word Expansion">Word Expansion</a>
+<li>working directory: <a href="#Working Directory">Working Directory</a>
+<li>write lock: <a href="#File Locks">File Locks</a>
+<li>writing to a file descriptor: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li>writing to a socket: <a href="#Transferring Data">Transferring Data</a>
+<li>writing to a stream, by blocks: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li>writing to a stream, by characters: <a href="#Simple Output">Simple Output</a>
+<li>writing to a stream, formatted: <a href="#Formatted Output">Formatted Output</a>
+<li>YP: <a href="#Host Identification">Host Identification</a>
+<li>YP domain name: <a href="#Host Identification">Host Identification</a>
+<li>zero divide: <a href="#FP Exceptions">FP Exceptions</a>
+</ul>
+<p><hr>
+Node:<a name="Type Index">Type Index</a>,
+Next:<a rel=next accesskey=n href="#Function Index">Function Index</a>,
+Previous:<a rel=previous accesskey=p href="#Concept Index">Concept Index</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Type Index</h2>
 
 <ul compact>
-<li><code>__ftw64_func_t</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>__ftw_func_t</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>__nftw64_func_t</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>__nftw_func_t</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>blkcnt64_t</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>blkcnt_t</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>cc_t</code>: <a href="#Mode%20Data%20Types">Mode Data Types</a>
-<li><code>clock_t</code>: <a href="#CPU%20Time">CPU Time</a>
-<li><code>comparison_fn_t</code>: <a href="#Comparison%20Functions">Comparison Functions</a>
-<li><code>cookie_close_function</code>: <a href="#Hook%20Functions">Hook Functions</a>
-<li><code>cookie_io_functions_t</code>: <a href="#Streams%20and%20Cookies">Streams and Cookies</a>
-<li><code>cookie_read_function</code>: <a href="#Hook%20Functions">Hook Functions</a>
-<li><code>cookie_seek_function</code>: <a href="#Hook%20Functions">Hook Functions</a>
-<li><code>cookie_write_function</code>: <a href="#Hook%20Functions">Hook Functions</a>
-<li><code>dev_t</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>DIR</code>: <a href="#Opening%20a%20Directory">Opening a Directory</a>
-<li><code>div_t</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>enum mcheck_status</code>: <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>
-<li><code>fd_set</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
+<li><code>__ftw64_func_t</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>__ftw_func_t</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>__nftw64_func_t</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>__nftw_func_t</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>blkcnt64_t</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>blkcnt_t</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>cc_t</code>: <a href="#Mode Data Types">Mode Data Types</a>
+<li><code>clock_t</code>: <a href="#CPU Time">CPU Time</a>
+<li><code>comparison_fn_t</code>: <a href="#Comparison Functions">Comparison Functions</a>
+<li><code>cookie_close_function</code>: <a href="#Hook Functions">Hook Functions</a>
+<li><code>cookie_io_functions_t</code>: <a href="#Streams and Cookies">Streams and Cookies</a>
+<li><code>cookie_read_function</code>: <a href="#Hook Functions">Hook Functions</a>
+<li><code>cookie_seek_function</code>: <a href="#Hook Functions">Hook Functions</a>
+<li><code>cookie_write_function</code>: <a href="#Hook Functions">Hook Functions</a>
+<li><code>dev_t</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>DIR</code>: <a href="#Opening a Directory">Opening a Directory</a>
+<li><code>div_t</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>enum mcheck_status</code>: <a href="#Heap Consistency Checking">Heap Consistency Checking</a>
+<li><code>fd_set</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
 <li><code>FILE</code>: <a href="#Streams">Streams</a>
-<li><code>fpos64_t</code>: <a href="#Portable%20Positioning">Portable Positioning</a>
-<li><code>fpos_t</code>: <a href="#Portable%20Positioning">Portable Positioning</a>
-<li><code>gid_t</code>: <a href="#Reading%20Persona">Reading Persona</a>
-<li><code>glob64_t</code>: <a href="#Calling%20Glob">Calling Glob</a>
-<li><code>glob_t</code>: <a href="#Calling%20Glob">Calling Glob</a>
-<li><code>iconv_t</code>: <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>
-<li><code>imaxdiv_t</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>ino64_t</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>ino_t</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>jmp_buf</code>: <a href="#Non-Local%20Details">Non-Local Details</a>
-<li><code>ldiv_t</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>lldiv_t</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>mbstate_t</code>: <a href="#Keeping%20the%20state">Keeping the state</a>
-<li><code>mode_t</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>nlink_t</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>off64_t</code>: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li><code>off_t</code>: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li><code>pid_t</code>: <a href="#Process%20Identification">Process Identification</a>
-<li><code>printf_arginfo_function</code>: <a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>
-<li><code>printf_function</code>: <a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>
-<li><code>ptrdiff_t</code>: <a href="#Important%20Data%20Types">Important Data Types</a>
-<li><code>regex_t</code>: <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>
-<li><code>regmatch_t</code>: <a href="#Regexp%20Subexpressions">Regexp Subexpressions</a>
-<li><code>regoff_t</code>: <a href="#Regexp%20Subexpressions">Regexp Subexpressions</a>
-<li><code>sig_atomic_t</code>: <a href="#Atomic%20Types">Atomic Types</a>
-<li><code>sighandler_t</code>: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><code>sigjmp_buf</code>: <a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>
-<li><code>sigset_t</code>: <a href="#Signal%20Sets">Signal Sets</a>
-<li><code>size_t</code>: <a href="#Important%20Data%20Types">Important Data Types</a>
-<li><code>speed_t</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>ssize_t</code>: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li><code>stack_t</code>: <a href="#Signal%20Stack">Signal Stack</a>
-<li><code>struct __gconv_step</code>: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li><code>struct __gconv_step_data</code>: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li><code>struct aiocb</code>: <a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
-<li><code>struct aiocb64</code>: <a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
-<li><code>struct aioinit</code>: <a href="#Configuration%20of%20AIO">Configuration of AIO</a>
-<li><code>struct argp</code>: <a href="#Argp%20Parsers">Argp Parsers</a>
-<li><code>struct argp_child</code>: <a href="#Argp%20Children">Argp Children</a>
-<li><code>struct argp_option</code>: <a href="#Argp%20Option%20Vectors">Argp Option Vectors</a>
-<li><code>struct argp_state</code>: <a href="#Argp%20Parsing%20State">Argp Parsing State</a>
-<li><code>struct dirent</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>struct ENTRY</code>: <a href="#Hash%20Search%20Function">Hash Search Function</a>
-<li><code>struct exit_status</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>struct flock</code>: <a href="#File%20Locks">File Locks</a>
+<li><code>fpos64_t</code>: <a href="#Portable Positioning">Portable Positioning</a>
+<li><code>fpos_t</code>: <a href="#Portable Positioning">Portable Positioning</a>
+<li><code>gid_t</code>: <a href="#Reading Persona">Reading Persona</a>
+<li><code>glob64_t</code>: <a href="#Calling Glob">Calling Glob</a>
+<li><code>glob_t</code>: <a href="#Calling Glob">Calling Glob</a>
+<li><code>iconv_t</code>: <a href="#Generic Conversion Interface">Generic Conversion Interface</a>
+<li><code>imaxdiv_t</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>ino64_t</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>ino_t</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>jmp_buf</code>: <a href="#Non-Local Details">Non-Local Details</a>
+<li><code>ldiv_t</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>lldiv_t</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>mbstate_t</code>: <a href="#Keeping the state">Keeping the state</a>
+<li><code>mode_t</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>nlink_t</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>off64_t</code>: <a href="#File Position Primitive">File Position Primitive</a>
+<li><code>off_t</code>: <a href="#File Position Primitive">File Position Primitive</a>
+<li><code>pid_t</code>: <a href="#Process Identification">Process Identification</a>
+<li><code>printf_arginfo_function</code>: <a href="#Defining the Output Handler">Defining the Output Handler</a>
+<li><code>printf_function</code>: <a href="#Defining the Output Handler">Defining the Output Handler</a>
+<li><code>ptrdiff_t</code>: <a href="#Important Data Types">Important Data Types</a>
+<li><code>regex_t</code>: <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>
+<li><code>regmatch_t</code>: <a href="#Regexp Subexpressions">Regexp Subexpressions</a>
+<li><code>regoff_t</code>: <a href="#Regexp Subexpressions">Regexp Subexpressions</a>
+<li><code>sig_atomic_t</code>: <a href="#Atomic Types">Atomic Types</a>
+<li><code>sighandler_t</code>: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><code>sigjmp_buf</code>: <a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>
+<li><code>sigset_t</code>: <a href="#Signal Sets">Signal Sets</a>
+<li><code>size_t</code>: <a href="#Important Data Types">Important Data Types</a>
+<li><code>speed_t</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>ssize_t</code>: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li><code>stack_t</code>: <a href="#Signal Stack">Signal Stack</a>
+<li><code>struct __gconv_step</code>: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li><code>struct __gconv_step_data</code>: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li><code>struct aiocb</code>: <a href="#Asynchronous I%2fO">Asynchronous I/O</a>
+<li><code>struct aiocb64</code>: <a href="#Asynchronous I%2fO">Asynchronous I/O</a>
+<li><code>struct aioinit</code>: <a href="#Configuration of AIO">Configuration of AIO</a>
+<li><code>struct argp</code>: <a href="#Argp Parsers">Argp Parsers</a>
+<li><code>struct argp_child</code>: <a href="#Argp Children">Argp Children</a>
+<li><code>struct argp_option</code>: <a href="#Argp Option Vectors">Argp Option Vectors</a>
+<li><code>struct argp_state</code>: <a href="#Argp Parsing State">Argp Parsing State</a>
+<li><code>struct dirent</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>struct ENTRY</code>: <a href="#Hash Search Function">Hash Search Function</a>
+<li><code>struct exit_status</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>struct flock</code>: <a href="#File Locks">File Locks</a>
 <li><code>struct fstab</code>: <a href="#fstab">fstab</a>
-<li><code>struct FTW</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>struct group</code>: <a href="#Group%20Data%20Structure">Group Data Structure</a>
-<li><code>struct hostent</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>struct if_nameindex</code>: <a href="#Interface%20Naming">Interface Naming</a>
-<li><code>struct in6_addr</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><code>struct in_addr</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
+<li><code>struct FTW</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>struct group</code>: <a href="#Group Data Structure">Group Data Structure</a>
+<li><code>struct hostent</code>: <a href="#Host Names">Host Names</a>
+<li><code>struct if_nameindex</code>: <a href="#Interface Naming">Interface Naming</a>
+<li><code>struct in6_addr</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
+<li><code>struct in_addr</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
 <li><code>struct iovec</code>: <a href="#Scatter-Gather">Scatter-Gather</a>
-<li><code>struct itimerval</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>struct lconv</code>: <a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>
-<li><code>struct linger</code>: <a href="#Socket-Level%20Options">Socket-Level Options</a>
-<li><code>struct mallinfo</code>: <a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>
+<li><code>struct itimerval</code>: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>struct lconv</code>: <a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>
+<li><code>struct linger</code>: <a href="#Socket-Level Options">Socket-Level Options</a>
+<li><code>struct mallinfo</code>: <a href="#Statistics of Malloc">Statistics of Malloc</a>
 <li><code>struct mntent</code>: <a href="#mtab">mtab</a>
-<li><code>struct netent</code>: <a href="#Networks%20Database">Networks Database</a>
-<li><code>struct ntptimeval</code>: <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li><code>struct obstack</code>: <a href="#Creating%20Obstacks">Creating Obstacks</a>
-<li><code>struct option</code>: <a href="#Getopt%20Long%20Options">Getopt Long Options</a>
-<li><code>struct passwd</code>: <a href="#User%20Data%20Structure">User Data Structure</a>
-<li><code>struct printf_info</code>: <a href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>
-<li><code>struct protoent</code>: <a href="#Protocols%20Database">Protocols Database</a>
-<li><code>struct random_data</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>struct rlimit</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>struct rlimit64</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>struct rusage</code>: <a href="#Resource%20Usage">Resource Usage</a>
-<li><code>struct sched_param</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>struct servent</code>: <a href="#Services%20Database">Services Database</a>
-<li><code>struct sgttyb</code>: <a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>
-<li><code>struct sigaction</code>: <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>
-<li><code>struct sigstack</code>: <a href="#Signal%20Stack">Signal Stack</a>
-<li><code>struct sigvec</code>: <a href="#BSD%20Handler">BSD Handler</a>
-<li><code>struct sockaddr</code>: <a href="#Address%20Formats">Address Formats</a>
-<li><code>struct sockaddr_in</code>: <a href="#Internet%20Address%20Formats">Internet Address Formats</a>
-<li><code>struct sockaddr_in6</code>: <a href="#Internet%20Address%20Formats">Internet Address Formats</a>
-<li><code>struct sockaddr_un</code>: <a href="#Local%20Namespace%20Details">Local Namespace Details</a>
-<li><code>struct stat</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>struct stat64</code>: <a href="#Attribute%20Meanings">Attribute Meanings</a>
-<li><code>struct termios</code>: <a href="#Mode%20Data%20Types">Mode Data Types</a>
-<li><code>struct timespec</code>: <a href="#Elapsed%20Time">Elapsed Time</a>
-<li><code>struct timeval</code>: <a href="#Elapsed%20Time">Elapsed Time</a>
-<li><code>struct timex</code>: <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li><code>struct timezone</code>: <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>
-<li><code>struct tm</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li><code>struct tms</code>: <a href="#Processor%20Time">Processor Time</a>
-<li><code>struct utimbuf</code>: <a href="#File%20Times">File Times</a>
-<li><code>struct utmp</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>struct utmpx</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>struct utsname</code>: <a href="#Platform%20Type">Platform Type</a>
-<li><code>struct vtimes</code>: <a href="#Resource%20Usage">Resource Usage</a>
-<li><code>tcflag_t</code>: <a href="#Mode%20Data%20Types">Mode Data Types</a>
-<li><code>time_t</code>: <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>
-<li><code>ucontext_t</code>: <a href="#System%20V%20contexts">System V contexts</a>
-<li><code>uid_t</code>: <a href="#Reading%20Persona">Reading Persona</a>
-<li><code>union wait</code>: <a href="#BSD%20Wait%20Functions">BSD Wait Functions</a>
-<li><code>va_list</code>: <a href="#Argument%20Macros">Argument Macros</a>
-<li><code>VISIT</code>: <a href="#Tree%20Search%20Function">Tree Search Function</a>
-<li><code>wchar_t</code>: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li><code>wctrans_t</code>: <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>
-<li><code>wctype_t</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>wint_t</code>: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li><code>wordexp_t</code>: <a href="#Calling%20Wordexp">Calling Wordexp</a>
-</ul>
-<p><hr>
-Node:<a name="Function%20Index">Function Index</a>,
-Next:<a rel=next accesskey=n href="#Variable%20Index">Variable Index</a>,
-Previous:<a rel=previous accesskey=p href="#Type%20Index">Type Index</a>,
+<li><code>struct netent</code>: <a href="#Networks Database">Networks Database</a>
+<li><code>struct ntptimeval</code>: <a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li><code>struct obstack</code>: <a href="#Creating Obstacks">Creating Obstacks</a>
+<li><code>struct option</code>: <a href="#Getopt Long Options">Getopt Long Options</a>
+<li><code>struct passwd</code>: <a href="#User Data Structure">User Data Structure</a>
+<li><code>struct printf_info</code>: <a href="#Conversion Specifier Options">Conversion Specifier Options</a>
+<li><code>struct protoent</code>: <a href="#Protocols Database">Protocols Database</a>
+<li><code>struct random_data</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>struct rlimit</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>struct rlimit64</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>struct rusage</code>: <a href="#Resource Usage">Resource Usage</a>
+<li><code>struct sched_param</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>struct servent</code>: <a href="#Services Database">Services Database</a>
+<li><code>struct sgttyb</code>: <a href="#BSD Terminal Modes">BSD Terminal Modes</a>
+<li><code>struct sigaction</code>: <a href="#Advanced Signal Handling">Advanced Signal Handling</a>
+<li><code>struct sigstack</code>: <a href="#Signal Stack">Signal Stack</a>
+<li><code>struct sigvec</code>: <a href="#BSD Handler">BSD Handler</a>
+<li><code>struct sockaddr</code>: <a href="#Address Formats">Address Formats</a>
+<li><code>struct sockaddr_in</code>: <a href="#Internet Address Formats">Internet Address Formats</a>
+<li><code>struct sockaddr_in6</code>: <a href="#Internet Address Formats">Internet Address Formats</a>
+<li><code>struct sockaddr_un</code>: <a href="#Local Namespace Details">Local Namespace Details</a>
+<li><code>struct stat</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>struct stat64</code>: <a href="#Attribute Meanings">Attribute Meanings</a>
+<li><code>struct termios</code>: <a href="#Mode Data Types">Mode Data Types</a>
+<li><code>struct timespec</code>: <a href="#Elapsed Time">Elapsed Time</a>
+<li><code>struct timeval</code>: <a href="#Elapsed Time">Elapsed Time</a>
+<li><code>struct timex</code>: <a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li><code>struct timezone</code>: <a href="#High-Resolution Calendar">High-Resolution Calendar</a>
+<li><code>struct tm</code>: <a href="#Broken-down Time">Broken-down Time</a>
+<li><code>struct tms</code>: <a href="#Processor Time">Processor Time</a>
+<li><code>struct utimbuf</code>: <a href="#File Times">File Times</a>
+<li><code>struct utmp</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>struct utmpx</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>struct utsname</code>: <a href="#Platform Type">Platform Type</a>
+<li><code>struct vtimes</code>: <a href="#Resource Usage">Resource Usage</a>
+<li><code>tcflag_t</code>: <a href="#Mode Data Types">Mode Data Types</a>
+<li><code>time_t</code>: <a href="#Simple Calendar Time">Simple Calendar Time</a>
+<li><code>ucontext_t</code>: <a href="#System V contexts">System V contexts</a>
+<li><code>uid_t</code>: <a href="#Reading Persona">Reading Persona</a>
+<li><code>union wait</code>: <a href="#BSD Wait Functions">BSD Wait Functions</a>
+<li><code>va_list</code>: <a href="#Argument Macros">Argument Macros</a>
+<li><code>VISIT</code>: <a href="#Tree Search Function">Tree Search Function</a>
+<li><code>wchar_t</code>: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li><code>wctrans_t</code>: <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>
+<li><code>wctype_t</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>wint_t</code>: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li><code>wordexp_t</code>: <a href="#Calling Wordexp">Calling Wordexp</a>
+</ul>
+<p><hr>
+Node:<a name="Function Index">Function Index</a>,
+Next:<a rel=next accesskey=n href="#Variable Index">Variable Index</a>,
+Previous:<a rel=previous accesskey=p href="#Type Index">Type Index</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Function and Macro Index</h2>
 
 <ul compact>
-<li><code>__fbufsize</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>__flbf</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>__fpending</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>__fpurge</code>: <a href="#Flushing%20Buffers">Flushing Buffers</a>
-<li><code>__freadable</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>__freading</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>__fsetlocking</code>: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><code>__fwritable</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>__fwriting</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>__va_copy</code>: <a href="#Argument%20Macros">Argument Macros</a>
-<li><code>_Exit</code>: <a href="#Termination%20Internals">Termination Internals</a>
-<li><code>_exit</code>: <a href="#Termination%20Internals">Termination Internals</a>
-<li><code>_flushlbf</code>: <a href="#Flushing%20Buffers">Flushing Buffers</a>
-<li><code>_tolower</code>: <a href="#Case%20Conversion">Case Conversion</a>
-<li><code>_toupper</code>: <a href="#Case%20Conversion">Case Conversion</a>
-<li><code>a64l</code>: <a href="#Encode%20Binary%20Data">Encode Binary Data</a>
-<li><code>abort</code>: <a href="#Aborting%20a%20Program">Aborting a Program</a>
-<li><code>abs</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>accept</code>: <a href="#Accepting%20Connections">Accepting Connections</a>
-<li><code>access</code>: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li><code>acos</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>acosf</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>acosh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>acoshf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>acoshl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>acosl</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
+<li><code>__fbufsize</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>__flbf</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>__fpending</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>__fpurge</code>: <a href="#Flushing Buffers">Flushing Buffers</a>
+<li><code>__freadable</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>__freading</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>__fsetlocking</code>: <a href="#Streams and Threads">Streams and Threads</a>
+<li><code>__fwritable</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>__fwriting</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>__va_copy</code>: <a href="#Argument Macros">Argument Macros</a>
+<li><code>_Exit</code>: <a href="#Termination Internals">Termination Internals</a>
+<li><code>_exit</code>: <a href="#Termination Internals">Termination Internals</a>
+<li><code>_flushlbf</code>: <a href="#Flushing Buffers">Flushing Buffers</a>
+<li><code>_tolower</code>: <a href="#Case Conversion">Case Conversion</a>
+<li><code>_toupper</code>: <a href="#Case Conversion">Case Conversion</a>
+<li><code>a64l</code>: <a href="#Encode Binary Data">Encode Binary Data</a>
+<li><code>abort</code>: <a href="#Aborting a Program">Aborting a Program</a>
+<li><code>abs</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>accept</code>: <a href="#Accepting Connections">Accepting Connections</a>
+<li><code>access</code>: <a href="#Testing File Access">Testing File Access</a>
+<li><code>acos</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>acosf</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>acosh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>acoshf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>acoshl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>acosl</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
 <li><code>addmntent</code>: <a href="#mtab">mtab</a>
-<li><code>addseverity</code>: <a href="#Adding%20Severity%20Classes">Adding Severity Classes</a>
-<li><code>adjtime</code>: <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>
-<li><code>adjtimex</code>: <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>
-<li><code>aio_cancel</code>: <a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>
-<li><code>aio_cancel64</code>: <a href="#Cancel%20AIO%20Operations">Cancel AIO Operations</a>
-<li><code>aio_error</code>: <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>
-<li><code>aio_error64</code>: <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>
-<li><code>aio_fsync</code>: <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>
-<li><code>aio_fsync64</code>: <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>
-<li><code>aio_init</code>: <a href="#Configuration%20of%20AIO">Configuration of AIO</a>
-<li><code>aio_read</code>: <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>
-<li><code>aio_read64</code>: <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>
-<li><code>aio_return</code>: <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>
-<li><code>aio_return64</code>: <a href="#Status%20of%20AIO%20Operations">Status of AIO Operations</a>
-<li><code>aio_suspend</code>: <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>
-<li><code>aio_suspend64</code>: <a href="#Synchronizing%20AIO%20Operations">Synchronizing AIO Operations</a>
-<li><code>aio_write</code>: <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>
-<li><code>aio_write64</code>: <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>
-<li><code>alarm</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>alloca</code>: <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>
-<li><code>alphasort</code>: <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>
-<li><code>alphasort64</code>: <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>
-<li><code>argp_error</code>: <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>
-<li><code>argp_failure</code>: <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>
-<li><code>argp_help</code>: <a href="#Argp%20Help">Argp Help</a>
+<li><code>addseverity</code>: <a href="#Adding Severity Classes">Adding Severity Classes</a>
+<li><code>adjtime</code>: <a href="#High-Resolution Calendar">High-Resolution Calendar</a>
+<li><code>adjtimex</code>: <a href="#High-Resolution Calendar">High-Resolution Calendar</a>
+<li><code>aio_cancel</code>: <a href="#Cancel AIO Operations">Cancel AIO Operations</a>
+<li><code>aio_cancel64</code>: <a href="#Cancel AIO Operations">Cancel AIO Operations</a>
+<li><code>aio_error</code>: <a href="#Status of AIO Operations">Status of AIO Operations</a>
+<li><code>aio_error64</code>: <a href="#Status of AIO Operations">Status of AIO Operations</a>
+<li><code>aio_fsync</code>: <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>
+<li><code>aio_fsync64</code>: <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>
+<li><code>aio_init</code>: <a href="#Configuration of AIO">Configuration of AIO</a>
+<li><code>aio_read</code>: <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>
+<li><code>aio_read64</code>: <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>
+<li><code>aio_return</code>: <a href="#Status of AIO Operations">Status of AIO Operations</a>
+<li><code>aio_return64</code>: <a href="#Status of AIO Operations">Status of AIO Operations</a>
+<li><code>aio_suspend</code>: <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>
+<li><code>aio_suspend64</code>: <a href="#Synchronizing AIO Operations">Synchronizing AIO Operations</a>
+<li><code>aio_write</code>: <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>
+<li><code>aio_write64</code>: <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>
+<li><code>alarm</code>: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>alloca</code>: <a href="#Variable Size Automatic">Variable Size Automatic</a>
+<li><code>alphasort</code>: <a href="#Scanning Directory Content">Scanning Directory Content</a>
+<li><code>alphasort64</code>: <a href="#Scanning Directory Content">Scanning Directory Content</a>
+<li><code>argp_error</code>: <a href="#Argp Helper Functions">Argp Helper Functions</a>
+<li><code>argp_failure</code>: <a href="#Argp Helper Functions">Argp Helper Functions</a>
+<li><code>argp_help</code>: <a href="#Argp Help">Argp Help</a>
 <li><code>argp_parse</code>: <a href="#Argp">Argp</a>
-<li><code>argp_state_help</code>: <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>
-<li><code>argp_usage</code>: <a href="#Argp%20Helper%20Functions">Argp Helper Functions</a>
-<li><code>argz_add</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_add_sep</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_append</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_count</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_create</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_create_sep</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_delete</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_extract</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_insert</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_next</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_replace</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>argz_stringify</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>asctime</code>: <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>
-<li><code>asctime_r</code>: <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>
-<li><code>asin</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>asinf</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>asinh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>asinhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>asinhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>asinl</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>asprintf</code>: <a href="#Dynamic%20Output">Dynamic Output</a>
-<li><code>assert</code>: <a href="#Consistency%20Checking">Consistency Checking</a>
-<li><code>assert_perror</code>: <a href="#Consistency%20Checking">Consistency Checking</a>
-<li><code>atan</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>atan2</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>atan2f</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>atan2l</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>atanf</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>atanh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>atanhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>atanhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>atanl</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>atexit</code>: <a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>
-<li><code>atof</code>: <a href="#Parsing%20of%20Floats">Parsing of Floats</a>
-<li><code>atoi</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>atol</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>atoll</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
+<li><code>argp_state_help</code>: <a href="#Argp Helper Functions">Argp Helper Functions</a>
+<li><code>argp_usage</code>: <a href="#Argp Helper Functions">Argp Helper Functions</a>
+<li><code>argz_add</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_add_sep</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_append</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_count</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_create</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_create_sep</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_delete</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_extract</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_insert</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_next</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_replace</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>argz_stringify</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>asctime</code>: <a href="#Formatting Calendar Time">Formatting Calendar Time</a>
+<li><code>asctime_r</code>: <a href="#Formatting Calendar Time">Formatting Calendar Time</a>
+<li><code>asin</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>asinf</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>asinh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>asinhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>asinhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>asinl</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>asprintf</code>: <a href="#Dynamic Output">Dynamic Output</a>
+<li><code>assert</code>: <a href="#Consistency Checking">Consistency Checking</a>
+<li><code>assert_perror</code>: <a href="#Consistency Checking">Consistency Checking</a>
+<li><code>atan</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>atan2</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>atan2f</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>atan2l</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>atanf</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>atanh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>atanhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>atanhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>atanl</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>atexit</code>: <a href="#Cleanups on Exit">Cleanups on Exit</a>
+<li><code>atof</code>: <a href="#Parsing of Floats">Parsing of Floats</a>
+<li><code>atoi</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>atol</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>atoll</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
 <li><code>backtrace</code>: <a href="#Backtraces">Backtraces</a>
 <li><code>backtrace_symbols</code>: <a href="#Backtraces">Backtraces</a>
 <li><code>backtrace_symbols_fd</code>: <a href="#Backtraces">Backtraces</a>
-<li><code>basename</code>: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li><code>bcmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>bcopy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>bind</code>: <a href="#Setting%20Address">Setting Address</a>
-<li><code>bind_textdomain_codeset</code>: <a href="#Charset%20conversion%20in%20gettext">Charset conversion in gettext</a>
-<li><code>bindtextdomain</code>: <a href="#Locating%20gettext%20catalog">Locating gettext catalog</a>
-<li><code>brk</code>: <a href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>
-<li><code>bsearch</code>: <a href="#Array%20Search%20Function">Array Search Function</a>
-<li><code>btowc</code>: <a href="#Converting%20a%20Character">Converting a Character</a>
-<li><code>bzero</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>cabs</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>cabsf</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>cabsl</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>cacos</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>cacosf</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>cacosh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>cacoshf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>cacoshl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>cacosl</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>calloc</code>: <a href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>
-<li><code>canonicalize_file_name</code>: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li><code>carg</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>cargf</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>cargl</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>casin</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>casinf</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>casinh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>casinhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>casinhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>casinl</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>catan</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>catanf</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>catanh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>catanhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>catanhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>catanl</code>: <a href="#Inverse%20Trig%20Functions">Inverse Trig Functions</a>
-<li><code>catclose</code>: <a href="#The%20catgets%20Functions">The catgets Functions</a>
-<li><code>catgets</code>: <a href="#The%20catgets%20Functions">The catgets Functions</a>
-<li><code>catopen</code>: <a href="#The%20catgets%20Functions">The catgets Functions</a>
-<li><code>cbc_crypt</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>cbrt</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cbrtf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cbrtl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>ccos</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>ccosf</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>ccosh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>ccoshf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>ccoshl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>ccosl</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>ceil</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>ceilf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>ceill</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>cexp</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cexpf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cexpl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cfgetispeed</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>cfgetospeed</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>cfmakeraw</code>: <a href="#Noncanonical%20Input">Noncanonical Input</a>
-<li><code>cfree</code>: <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>
-<li><code>cfsetispeed</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>cfsetospeed</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>cfsetspeed</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>chdir</code>: <a href="#Working%20Directory">Working Directory</a>
-<li><code>chmod</code>: <a href="#Setting%20Permissions">Setting Permissions</a>
-<li><code>chown</code>: <a href="#File%20Owner">File Owner</a>
-<li><code>cimag</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>cimagf</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>cimagl</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>clearenv</code>: <a href="#Environment%20Access">Environment Access</a>
-<li><code>clearerr</code>: <a href="#Error%20Recovery">Error Recovery</a>
-<li><code>clearerr_unlocked</code>: <a href="#Error%20Recovery">Error Recovery</a>
-<li><code>clock</code>: <a href="#CPU%20Time">CPU Time</a>
-<li><code>clog</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>clog10</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>clog10f</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>clog10l</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>clogf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>clogl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>close</code>: <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li><code>closedir</code>: <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>
+<li><code>basename</code>: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li><code>bcmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>bcopy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>bind</code>: <a href="#Setting Address">Setting Address</a>
+<li><code>bind_textdomain_codeset</code>: <a href="#Charset conversion in gettext">Charset conversion in gettext</a>
+<li><code>bindtextdomain</code>: <a href="#Locating gettext catalog">Locating gettext catalog</a>
+<li><code>brk</code>: <a href="#Resizing the Data Segment">Resizing the Data Segment</a>
+<li><code>bsearch</code>: <a href="#Array Search Function">Array Search Function</a>
+<li><code>btowc</code>: <a href="#Converting a Character">Converting a Character</a>
+<li><code>bzero</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>cabs</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>cabsf</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>cabsl</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>cacos</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>cacosf</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>cacosh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>cacoshf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>cacoshl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>cacosl</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>calloc</code>: <a href="#Allocating Cleared Space">Allocating Cleared Space</a>
+<li><code>canonicalize_file_name</code>: <a href="#Symbolic Links">Symbolic Links</a>
+<li><code>carg</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>cargf</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>cargl</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>casin</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>casinf</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>casinh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>casinhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>casinhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>casinl</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>catan</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>catanf</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>catanh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>catanhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>catanhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>catanl</code>: <a href="#Inverse Trig Functions">Inverse Trig Functions</a>
+<li><code>catclose</code>: <a href="#The catgets Functions">The catgets Functions</a>
+<li><code>catgets</code>: <a href="#The catgets Functions">The catgets Functions</a>
+<li><code>catopen</code>: <a href="#The catgets Functions">The catgets Functions</a>
+<li><code>cbc_crypt</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>cbrt</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cbrtf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cbrtl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>ccos</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>ccosf</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>ccosh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>ccoshf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>ccoshl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>ccosl</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>ceil</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>ceilf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>ceill</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>cexp</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cexpf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cexpl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cfgetispeed</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>cfgetospeed</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>cfmakeraw</code>: <a href="#Noncanonical Input">Noncanonical Input</a>
+<li><code>cfree</code>: <a href="#Freeing after Malloc">Freeing after Malloc</a>
+<li><code>cfsetispeed</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>cfsetospeed</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>cfsetspeed</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>chdir</code>: <a href="#Working Directory">Working Directory</a>
+<li><code>chmod</code>: <a href="#Setting Permissions">Setting Permissions</a>
+<li><code>chown</code>: <a href="#File Owner">File Owner</a>
+<li><code>cimag</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>cimagf</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>cimagl</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>clearenv</code>: <a href="#Environment Access">Environment Access</a>
+<li><code>clearerr</code>: <a href="#Error Recovery">Error Recovery</a>
+<li><code>clearerr_unlocked</code>: <a href="#Error Recovery">Error Recovery</a>
+<li><code>clock</code>: <a href="#CPU Time">CPU Time</a>
+<li><code>clog</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>clog10</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>clog10f</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>clog10l</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>clogf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>clogl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>close</code>: <a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li><code>closedir</code>: <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>
 <li><code>closelog</code>: <a href="#closelog">closelog</a>
-<li><code>confstr</code>: <a href="#String%20Parameters">String Parameters</a>
-<li><code>conj</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>conjf</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>conjl</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
+<li><code>confstr</code>: <a href="#String Parameters">String Parameters</a>
+<li><code>conj</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>conjf</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>conjl</code>: <a href="#Operations on Complex">Operations on Complex</a>
 <li><code>connect</code>: <a href="#Connecting">Connecting</a>
-<li><code>copysign</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>copysignf</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>copysignl</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>cos</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>cosf</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>cosh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>coshf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>coshl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>cosl</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>cpow</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cpowf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cpowl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>cproj</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>cprojf</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>cprojl</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>creal</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>crealf</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>creall</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>
-<li><code>creat</code>: <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li><code>creat64</code>: <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
+<li><code>copysign</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>copysignf</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>copysignl</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>cos</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>cosf</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>cosh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>coshf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>coshl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>cosl</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>cpow</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cpowf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cpowl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>cproj</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>cprojf</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>cprojl</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>creal</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>crealf</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>creall</code>: <a href="#Operations on Complex">Operations on Complex</a>
+<li><code>creat</code>: <a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li><code>creat64</code>: <a href="#Opening and Closing Files">Opening and Closing Files</a>
 <li><code>crypt</code>: <a href="#crypt">crypt</a>
 <li><code>crypt_r</code>: <a href="#crypt">crypt</a>
-<li><code>csin</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>csinf</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>csinh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>csinhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>csinhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>csinl</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>csqrt</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>csqrtf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>csqrtl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>ctan</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>ctanf</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>ctanh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>ctanhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>ctanhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>ctanl</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>ctermid</code>: <a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>
-<li><code>ctime</code>: <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>
-<li><code>ctime_r</code>: <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>
-<li><code>cuserid</code>: <a href="#Who%20Logged%20In">Who Logged In</a>
-<li><code>dcgettext</code>: <a href="#Translation%20with%20gettext">Translation with gettext</a>
-<li><code>dcngettext</code>: <a href="#Advanced%20gettext%20functions">Advanced gettext functions</a>
-<li><code>DES_FAILED</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>des_setparity</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>dgettext</code>: <a href="#Translation%20with%20gettext">Translation with gettext</a>
-<li><code>difftime</code>: <a href="#Elapsed%20Time">Elapsed Time</a>
-<li><code>dirfd</code>: <a href="#Opening%20a%20Directory">Opening a Directory</a>
-<li><code>dirname</code>: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li><code>div</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>dngettext</code>: <a href="#Advanced%20gettext%20functions">Advanced gettext functions</a>
-<li><code>drand48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>drand48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>drem</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>dremf</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>dreml</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>DTTOIF</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>dup</code>: <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>
-<li><code>dup2</code>: <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>
-<li><code>ecb_crypt</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>ecvt</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>ecvt_r</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>encrypt</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>encrypt_r</code>: <a href="#DES%20Encryption">DES Encryption</a>
+<li><code>csin</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>csinf</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>csinh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>csinhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>csinhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>csinl</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>csqrt</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>csqrtf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>csqrtl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>ctan</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>ctanf</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>ctanh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>ctanhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>ctanhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>ctanl</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>ctermid</code>: <a href="#Identifying the Terminal">Identifying the Terminal</a>
+<li><code>ctime</code>: <a href="#Formatting Calendar Time">Formatting Calendar Time</a>
+<li><code>ctime_r</code>: <a href="#Formatting Calendar Time">Formatting Calendar Time</a>
+<li><code>cuserid</code>: <a href="#Who Logged In">Who Logged In</a>
+<li><code>dcgettext</code>: <a href="#Translation with gettext">Translation with gettext</a>
+<li><code>dcngettext</code>: <a href="#Advanced gettext functions">Advanced gettext functions</a>
+<li><code>DES_FAILED</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>des_setparity</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>dgettext</code>: <a href="#Translation with gettext">Translation with gettext</a>
+<li><code>difftime</code>: <a href="#Elapsed Time">Elapsed Time</a>
+<li><code>dirfd</code>: <a href="#Opening a Directory">Opening a Directory</a>
+<li><code>dirname</code>: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li><code>div</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>dngettext</code>: <a href="#Advanced gettext functions">Advanced gettext functions</a>
+<li><code>drand48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>drand48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>drem</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>dremf</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>dreml</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>DTTOIF</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>dup</code>: <a href="#Duplicating Descriptors">Duplicating Descriptors</a>
+<li><code>dup2</code>: <a href="#Duplicating Descriptors">Duplicating Descriptors</a>
+<li><code>ecb_crypt</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>ecvt</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>ecvt_r</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>encrypt</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>encrypt_r</code>: <a href="#DES Encryption">DES Encryption</a>
 <li><code>endfsent</code>: <a href="#fstab">fstab</a>
-<li><code>endgrent</code>: <a href="#Scanning%20All%20Groups">Scanning All Groups</a>
-<li><code>endhostent</code>: <a href="#Host%20Names">Host Names</a>
+<li><code>endgrent</code>: <a href="#Scanning All Groups">Scanning All Groups</a>
+<li><code>endhostent</code>: <a href="#Host Names">Host Names</a>
 <li><code>endmntent</code>: <a href="#mtab">mtab</a>
-<li><code>endnetent</code>: <a href="#Networks%20Database">Networks Database</a>
-<li><code>endnetgrent</code>: <a href="#Lookup%20Netgroup">Lookup Netgroup</a>
-<li><code>endprotoent</code>: <a href="#Protocols%20Database">Protocols Database</a>
-<li><code>endpwent</code>: <a href="#Scanning%20All%20Users">Scanning All Users</a>
-<li><code>endservent</code>: <a href="#Services%20Database">Services Database</a>
-<li><code>endutent</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>endutxent</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>envz_add</code>: <a href="#Envz%20Functions">Envz Functions</a>
-<li><code>envz_entry</code>: <a href="#Envz%20Functions">Envz Functions</a>
-<li><code>envz_get</code>: <a href="#Envz%20Functions">Envz Functions</a>
-<li><code>envz_merge</code>: <a href="#Envz%20Functions">Envz Functions</a>
-<li><code>envz_strip</code>: <a href="#Envz%20Functions">Envz Functions</a>
-<li><code>erand48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>erand48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>erf</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>erfc</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>erfcf</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>erfcl</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>erff</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>erfl</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>err</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>error</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>error_at_line</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>errx</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>execl</code>: <a href="#Executing%20a%20File">Executing a File</a>
-<li><code>execle</code>: <a href="#Executing%20a%20File">Executing a File</a>
-<li><code>execlp</code>: <a href="#Executing%20a%20File">Executing a File</a>
-<li><code>execv</code>: <a href="#Executing%20a%20File">Executing a File</a>
-<li><code>execve</code>: <a href="#Executing%20a%20File">Executing a File</a>
-<li><code>execvp</code>: <a href="#Executing%20a%20File">Executing a File</a>
-<li><code>exit</code>: <a href="#Normal%20Termination">Normal Termination</a>
-<li><code>exp</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>exp10</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>exp10f</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>exp10l</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>exp2</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>exp2f</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>exp2l</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>expf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>expl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>expm1</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>expm1f</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>expm1l</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>fabs</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>fabsf</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>fabsl</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>fchdir</code>: <a href="#Working%20Directory">Working Directory</a>
-<li><code>fchmod</code>: <a href="#Setting%20Permissions">Setting Permissions</a>
-<li><code>fchown</code>: <a href="#File%20Owner">File Owner</a>
-<li><code>fclean</code>: <a href="#Cleaning%20Streams">Cleaning Streams</a>
-<li><code>fclose</code>: <a href="#Closing%20Streams">Closing Streams</a>
-<li><code>fcloseall</code>: <a href="#Closing%20Streams">Closing Streams</a>
-<li><code>fcntl</code>: <a href="#Control%20Operations">Control Operations</a>
-<li><code>fcvt</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>fcvt_r</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>FD_CLR</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li><code>FD_ISSET</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li><code>FD_SET</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li><code>FD_ZERO</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li><code>fdatasync</code>: <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>
-<li><code>fdim</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fdimf</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fdiml</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fdopen</code>: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><code>feclearexcept</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
-<li><code>fedisableexcept</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>feenableexcept</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>fegetenv</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>fegetexcept</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>fegetexceptflag</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
+<li><code>endnetent</code>: <a href="#Networks Database">Networks Database</a>
+<li><code>endnetgrent</code>: <a href="#Lookup Netgroup">Lookup Netgroup</a>
+<li><code>endprotoent</code>: <a href="#Protocols Database">Protocols Database</a>
+<li><code>endpwent</code>: <a href="#Scanning All Users">Scanning All Users</a>
+<li><code>endservent</code>: <a href="#Services Database">Services Database</a>
+<li><code>endutent</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>endutxent</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>envz_add</code>: <a href="#Envz Functions">Envz Functions</a>
+<li><code>envz_entry</code>: <a href="#Envz Functions">Envz Functions</a>
+<li><code>envz_get</code>: <a href="#Envz Functions">Envz Functions</a>
+<li><code>envz_merge</code>: <a href="#Envz Functions">Envz Functions</a>
+<li><code>envz_strip</code>: <a href="#Envz Functions">Envz Functions</a>
+<li><code>erand48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>erand48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>erf</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>erfc</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>erfcf</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>erfcl</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>erff</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>erfl</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>err</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>error</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>error_at_line</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>errx</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>execl</code>: <a href="#Executing a File">Executing a File</a>
+<li><code>execle</code>: <a href="#Executing a File">Executing a File</a>
+<li><code>execlp</code>: <a href="#Executing a File">Executing a File</a>
+<li><code>execv</code>: <a href="#Executing a File">Executing a File</a>
+<li><code>execve</code>: <a href="#Executing a File">Executing a File</a>
+<li><code>execvp</code>: <a href="#Executing a File">Executing a File</a>
+<li><code>exit</code>: <a href="#Normal Termination">Normal Termination</a>
+<li><code>exp</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>exp10</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>exp10f</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>exp10l</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>exp2</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>exp2f</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>exp2l</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>expf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>expl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>expm1</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>expm1f</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>expm1l</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>fabs</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>fabsf</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>fabsl</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>fchdir</code>: <a href="#Working Directory">Working Directory</a>
+<li><code>fchmod</code>: <a href="#Setting Permissions">Setting Permissions</a>
+<li><code>fchown</code>: <a href="#File Owner">File Owner</a>
+<li><code>fclean</code>: <a href="#Cleaning Streams">Cleaning Streams</a>
+<li><code>fclose</code>: <a href="#Closing Streams">Closing Streams</a>
+<li><code>fcloseall</code>: <a href="#Closing Streams">Closing Streams</a>
+<li><code>fcntl</code>: <a href="#Control Operations">Control Operations</a>
+<li><code>fcvt</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>fcvt_r</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>FD_CLR</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li><code>FD_ISSET</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li><code>FD_SET</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li><code>FD_ZERO</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li><code>fdatasync</code>: <a href="#Synchronizing I%2fO">Synchronizing I/O</a>
+<li><code>fdim</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fdimf</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fdiml</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fdopen</code>: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><code>feclearexcept</code>: <a href="#Status bit operations">Status bit operations</a>
+<li><code>fedisableexcept</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>feenableexcept</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>fegetenv</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>fegetexcept</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>fegetexceptflag</code>: <a href="#Status bit operations">Status bit operations</a>
 <li><code>fegetround</code>: <a href="#Rounding">Rounding</a>
-<li><code>feholdexcept</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>feof</code>: <a href="#EOF%20and%20Errors">EOF and Errors</a>
-<li><code>feof_unlocked</code>: <a href="#EOF%20and%20Errors">EOF and Errors</a>
-<li><code>feraiseexcept</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
-<li><code>ferror</code>: <a href="#EOF%20and%20Errors">EOF and Errors</a>
-<li><code>ferror_unlocked</code>: <a href="#EOF%20and%20Errors">EOF and Errors</a>
-<li><code>fesetenv</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>fesetexceptflag</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
+<li><code>feholdexcept</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>feof</code>: <a href="#EOF and Errors">EOF and Errors</a>
+<li><code>feof_unlocked</code>: <a href="#EOF and Errors">EOF and Errors</a>
+<li><code>feraiseexcept</code>: <a href="#Status bit operations">Status bit operations</a>
+<li><code>ferror</code>: <a href="#EOF and Errors">EOF and Errors</a>
+<li><code>ferror_unlocked</code>: <a href="#EOF and Errors">EOF and Errors</a>
+<li><code>fesetenv</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>fesetexceptflag</code>: <a href="#Status bit operations">Status bit operations</a>
 <li><code>fesetround</code>: <a href="#Rounding">Rounding</a>
-<li><code>fetestexcept</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
-<li><code>feupdateenv</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>fflush</code>: <a href="#Flushing%20Buffers">Flushing Buffers</a>
-<li><code>fflush_unlocked</code>: <a href="#Flushing%20Buffers">Flushing Buffers</a>
-<li><code>fgetc</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>fgetc_unlocked</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>fgetgrent</code>: <a href="#Scanning%20All%20Groups">Scanning All Groups</a>
-<li><code>fgetgrent_r</code>: <a href="#Scanning%20All%20Groups">Scanning All Groups</a>
-<li><code>fgetpos</code>: <a href="#Portable%20Positioning">Portable Positioning</a>
-<li><code>fgetpos64</code>: <a href="#Portable%20Positioning">Portable Positioning</a>
-<li><code>fgetpwent</code>: <a href="#Scanning%20All%20Users">Scanning All Users</a>
-<li><code>fgetpwent_r</code>: <a href="#Scanning%20All%20Users">Scanning All Users</a>
-<li><code>fgets</code>: <a href="#Line%20Input">Line Input</a>
-<li><code>fgets_unlocked</code>: <a href="#Line%20Input">Line Input</a>
-<li><code>fgetwc</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>fgetwc_unlocked</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>fgetws</code>: <a href="#Line%20Input">Line Input</a>
-<li><code>fgetws_unlocked</code>: <a href="#Line%20Input">Line Input</a>
-<li><code>fileno</code>: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><code>fileno_unlocked</code>: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><code>finite</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>finitef</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>finitel</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>flockfile</code>: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><code>floor</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>floorf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>floorl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>fma</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fmaf</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fmal</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fmax</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fmaxf</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fmaxl</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fmemopen</code>: <a href="#String%20Streams">String Streams</a>
-<li><code>fmin</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fminf</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fminl</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>fmod</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>fmodf</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>fmodl</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>fmtmsg</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>fnmatch</code>: <a href="#Wildcard%20Matching">Wildcard Matching</a>
-<li><code>fopen</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>fopen64</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>fopencookie</code>: <a href="#Streams%20and%20Cookies">Streams and Cookies</a>
-<li><code>fork</code>: <a href="#Creating%20a%20Process">Creating a Process</a>
-<li><code>forkpty</code>: <a href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>
+<li><code>fetestexcept</code>: <a href="#Status bit operations">Status bit operations</a>
+<li><code>feupdateenv</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>fflush</code>: <a href="#Flushing Buffers">Flushing Buffers</a>
+<li><code>fflush_unlocked</code>: <a href="#Flushing Buffers">Flushing Buffers</a>
+<li><code>fgetc</code>: <a href="#Character Input">Character Input</a>
+<li><code>fgetc_unlocked</code>: <a href="#Character Input">Character Input</a>
+<li><code>fgetgrent</code>: <a href="#Scanning All Groups">Scanning All Groups</a>
+<li><code>fgetgrent_r</code>: <a href="#Scanning All Groups">Scanning All Groups</a>
+<li><code>fgetpos</code>: <a href="#Portable Positioning">Portable Positioning</a>
+<li><code>fgetpos64</code>: <a href="#Portable Positioning">Portable Positioning</a>
+<li><code>fgetpwent</code>: <a href="#Scanning All Users">Scanning All Users</a>
+<li><code>fgetpwent_r</code>: <a href="#Scanning All Users">Scanning All Users</a>
+<li><code>fgets</code>: <a href="#Line Input">Line Input</a>
+<li><code>fgets_unlocked</code>: <a href="#Line Input">Line Input</a>
+<li><code>fgetwc</code>: <a href="#Character Input">Character Input</a>
+<li><code>fgetwc_unlocked</code>: <a href="#Character Input">Character Input</a>
+<li><code>fgetws</code>: <a href="#Line Input">Line Input</a>
+<li><code>fgetws_unlocked</code>: <a href="#Line Input">Line Input</a>
+<li><code>fileno</code>: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><code>fileno_unlocked</code>: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><code>finite</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>finitef</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>finitel</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>flockfile</code>: <a href="#Streams and Threads">Streams and Threads</a>
+<li><code>floor</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>floorf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>floorl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>fma</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fmaf</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fmal</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fmax</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fmaxf</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fmaxl</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fmemopen</code>: <a href="#String Streams">String Streams</a>
+<li><code>fmin</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fminf</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fminl</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>fmod</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>fmodf</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>fmodl</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>fmtmsg</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>fnmatch</code>: <a href="#Wildcard Matching">Wildcard Matching</a>
+<li><code>fopen</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>fopen64</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>fopencookie</code>: <a href="#Streams and Cookies">Streams and Cookies</a>
+<li><code>fork</code>: <a href="#Creating a Process">Creating a Process</a>
+<li><code>forkpty</code>: <a href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>
 <li><code>fpathconf</code>: <a href="#Pathconf">Pathconf</a>
-<li><code>fpclassify</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>fprintf</code>: <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><code>fputc</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fputc_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fputs</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fputs_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fputwc</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fputwc_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fputws</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fputws_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>fread</code>: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li><code>fread_unlocked</code>: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li><code>free</code>: <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>
-<li><code>freopen</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>freopen64</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>frexp</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>frexpf</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>frexpl</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>fscanf</code>: <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>
-<li><code>fseek</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>fseeko</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>fseeko64</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>fsetpos</code>: <a href="#Portable%20Positioning">Portable Positioning</a>
-<li><code>fsetpos64</code>: <a href="#Portable%20Positioning">Portable Positioning</a>
-<li><code>fstat</code>: <a href="#Reading%20Attributes">Reading Attributes</a>
-<li><code>fstat64</code>: <a href="#Reading%20Attributes">Reading Attributes</a>
-<li><code>fsync</code>: <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>
-<li><code>ftell</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>ftello</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>ftello64</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>ftruncate</code>: <a href="#File%20Size">File Size</a>
-<li><code>ftruncate64</code>: <a href="#File%20Size">File Size</a>
-<li><code>ftrylockfile</code>: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><code>ftw</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>ftw64</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>funlockfile</code>: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><code>fwide</code>: <a href="#Streams%20and%20I18N">Streams and I18N</a>
-<li><code>fwprintf</code>: <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><code>fwrite</code>: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li><code>fwrite_unlocked</code>: <a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li><code>fwscanf</code>: <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>
-<li><code>gamma</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>gammaf</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>gammal</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>gcvt</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>get_avphys_pages</code>: <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>
-<li><code>get_current_dir_name</code>: <a href="#Working%20Directory">Working Directory</a>
-<li><code>get_nprocs</code>: <a href="#Processor%20Resources">Processor Resources</a>
-<li><code>get_nprocs_conf</code>: <a href="#Processor%20Resources">Processor Resources</a>
-<li><code>get_phys_pages</code>: <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>
-<li><code>getc</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getc_unlocked</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getchar</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getchar_unlocked</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getcontext</code>: <a href="#System%20V%20contexts">System V contexts</a>
-<li><code>getcwd</code>: <a href="#Working%20Directory">Working Directory</a>
-<li><code>getdate</code>: <a href="#General%20Time%20String%20Parsing">General Time String Parsing</a>
-<li><code>getdate_r</code>: <a href="#General%20Time%20String%20Parsing">General Time String Parsing</a>
-<li><code>getdelim</code>: <a href="#Line%20Input">Line Input</a>
-<li><code>getdomainnname</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>getegid</code>: <a href="#Reading%20Persona">Reading Persona</a>
-<li><code>getenv</code>: <a href="#Environment%20Access">Environment Access</a>
-<li><code>geteuid</code>: <a href="#Reading%20Persona">Reading Persona</a>
+<li><code>fpclassify</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>fprintf</code>: <a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><code>fputc</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fputc_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fputs</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fputs_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fputwc</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fputwc_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fputws</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fputws_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>fread</code>: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li><code>fread_unlocked</code>: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li><code>free</code>: <a href="#Freeing after Malloc">Freeing after Malloc</a>
+<li><code>freopen</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>freopen64</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>frexp</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>frexpf</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>frexpl</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>fscanf</code>: <a href="#Formatted Input Functions">Formatted Input Functions</a>
+<li><code>fseek</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>fseeko</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>fseeko64</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>fsetpos</code>: <a href="#Portable Positioning">Portable Positioning</a>
+<li><code>fsetpos64</code>: <a href="#Portable Positioning">Portable Positioning</a>
+<li><code>fstat</code>: <a href="#Reading Attributes">Reading Attributes</a>
+<li><code>fstat64</code>: <a href="#Reading Attributes">Reading Attributes</a>
+<li><code>fsync</code>: <a href="#Synchronizing I%2fO">Synchronizing I/O</a>
+<li><code>ftell</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>ftello</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>ftello64</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>ftruncate</code>: <a href="#File Size">File Size</a>
+<li><code>ftruncate64</code>: <a href="#File Size">File Size</a>
+<li><code>ftrylockfile</code>: <a href="#Streams and Threads">Streams and Threads</a>
+<li><code>ftw</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>ftw64</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>funlockfile</code>: <a href="#Streams and Threads">Streams and Threads</a>
+<li><code>fwide</code>: <a href="#Streams and I18N">Streams and I18N</a>
+<li><code>fwprintf</code>: <a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><code>fwrite</code>: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li><code>fwrite_unlocked</code>: <a href="#Block Input%2fOutput">Block Input/Output</a>
+<li><code>fwscanf</code>: <a href="#Formatted Input Functions">Formatted Input Functions</a>
+<li><code>gamma</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>gammaf</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>gammal</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>gcvt</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>get_avphys_pages</code>: <a href="#Query Memory Parameters">Query Memory Parameters</a>
+<li><code>get_current_dir_name</code>: <a href="#Working Directory">Working Directory</a>
+<li><code>get_nprocs</code>: <a href="#Processor Resources">Processor Resources</a>
+<li><code>get_nprocs_conf</code>: <a href="#Processor Resources">Processor Resources</a>
+<li><code>get_phys_pages</code>: <a href="#Query Memory Parameters">Query Memory Parameters</a>
+<li><code>getc</code>: <a href="#Character Input">Character Input</a>
+<li><code>getc_unlocked</code>: <a href="#Character Input">Character Input</a>
+<li><code>getchar</code>: <a href="#Character Input">Character Input</a>
+<li><code>getchar_unlocked</code>: <a href="#Character Input">Character Input</a>
+<li><code>getcontext</code>: <a href="#System V contexts">System V contexts</a>
+<li><code>getcwd</code>: <a href="#Working Directory">Working Directory</a>
+<li><code>getdate</code>: <a href="#General Time String Parsing">General Time String Parsing</a>
+<li><code>getdate_r</code>: <a href="#General Time String Parsing">General Time String Parsing</a>
+<li><code>getdelim</code>: <a href="#Line Input">Line Input</a>
+<li><code>getdomainnname</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>getegid</code>: <a href="#Reading Persona">Reading Persona</a>
+<li><code>getenv</code>: <a href="#Environment Access">Environment Access</a>
+<li><code>geteuid</code>: <a href="#Reading Persona">Reading Persona</a>
 <li><code>getfsent</code>: <a href="#fstab">fstab</a>
 <li><code>getfsfile</code>: <a href="#fstab">fstab</a>
 <li><code>getfsspec</code>: <a href="#fstab">fstab</a>
-<li><code>getgid</code>: <a href="#Reading%20Persona">Reading Persona</a>
-<li><code>getgrent</code>: <a href="#Scanning%20All%20Groups">Scanning All Groups</a>
-<li><code>getgrent_r</code>: <a href="#Scanning%20All%20Groups">Scanning All Groups</a>
-<li><code>getgrgid</code>: <a href="#Lookup%20Group">Lookup Group</a>
-<li><code>getgrgid_r</code>: <a href="#Lookup%20Group">Lookup Group</a>
-<li><code>getgrnam</code>: <a href="#Lookup%20Group">Lookup Group</a>
-<li><code>getgrnam_r</code>: <a href="#Lookup%20Group">Lookup Group</a>
-<li><code>getgrouplist</code>: <a href="#Setting%20Groups">Setting Groups</a>
-<li><code>getgroups</code>: <a href="#Reading%20Persona">Reading Persona</a>
-<li><code>gethostbyaddr</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>gethostbyaddr_r</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>gethostbyname</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>gethostbyname2</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>gethostbyname2_r</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>gethostbyname_r</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>gethostent</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>gethostid</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>gethostname</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>getitimer</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>getline</code>: <a href="#Line%20Input">Line Input</a>
-<li><code>getloadavg</code>: <a href="#Processor%20Resources">Processor Resources</a>
-<li><code>getlogin</code>: <a href="#Who%20Logged%20In">Who Logged In</a>
+<li><code>getgid</code>: <a href="#Reading Persona">Reading Persona</a>
+<li><code>getgrent</code>: <a href="#Scanning All Groups">Scanning All Groups</a>
+<li><code>getgrent_r</code>: <a href="#Scanning All Groups">Scanning All Groups</a>
+<li><code>getgrgid</code>: <a href="#Lookup Group">Lookup Group</a>
+<li><code>getgrgid_r</code>: <a href="#Lookup Group">Lookup Group</a>
+<li><code>getgrnam</code>: <a href="#Lookup Group">Lookup Group</a>
+<li><code>getgrnam_r</code>: <a href="#Lookup Group">Lookup Group</a>
+<li><code>getgrouplist</code>: <a href="#Setting Groups">Setting Groups</a>
+<li><code>getgroups</code>: <a href="#Reading Persona">Reading Persona</a>
+<li><code>gethostbyaddr</code>: <a href="#Host Names">Host Names</a>
+<li><code>gethostbyaddr_r</code>: <a href="#Host Names">Host Names</a>
+<li><code>gethostbyname</code>: <a href="#Host Names">Host Names</a>
+<li><code>gethostbyname2</code>: <a href="#Host Names">Host Names</a>
+<li><code>gethostbyname2_r</code>: <a href="#Host Names">Host Names</a>
+<li><code>gethostbyname_r</code>: <a href="#Host Names">Host Names</a>
+<li><code>gethostent</code>: <a href="#Host Names">Host Names</a>
+<li><code>gethostid</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>gethostname</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>getitimer</code>: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>getline</code>: <a href="#Line Input">Line Input</a>
+<li><code>getloadavg</code>: <a href="#Processor Resources">Processor Resources</a>
+<li><code>getlogin</code>: <a href="#Who Logged In">Who Logged In</a>
 <li><code>getmntent</code>: <a href="#mtab">mtab</a>
 <li><code>getmntent_r</code>: <a href="#mtab">mtab</a>
-<li><code>getnetbyaddr</code>: <a href="#Networks%20Database">Networks Database</a>
-<li><code>getnetbyname</code>: <a href="#Networks%20Database">Networks Database</a>
-<li><code>getnetent</code>: <a href="#Networks%20Database">Networks Database</a>
-<li><code>getnetgrent</code>: <a href="#Lookup%20Netgroup">Lookup Netgroup</a>
-<li><code>getnetgrent_r</code>: <a href="#Lookup%20Netgroup">Lookup Netgroup</a>
-<li><code>getopt</code>: <a href="#Using%20Getopt">Using Getopt</a>
-<li><code>getopt_long</code>: <a href="#Getopt%20Long%20Options">Getopt Long Options</a>
-<li><code>getopt_long_only</code>: <a href="#Getopt%20Long%20Options">Getopt Long Options</a>
-<li><code>getpagesize</code>: <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>
+<li><code>getnetbyaddr</code>: <a href="#Networks Database">Networks Database</a>
+<li><code>getnetbyname</code>: <a href="#Networks Database">Networks Database</a>
+<li><code>getnetent</code>: <a href="#Networks Database">Networks Database</a>
+<li><code>getnetgrent</code>: <a href="#Lookup Netgroup">Lookup Netgroup</a>
+<li><code>getnetgrent_r</code>: <a href="#Lookup Netgroup">Lookup Netgroup</a>
+<li><code>getopt</code>: <a href="#Using Getopt">Using Getopt</a>
+<li><code>getopt_long</code>: <a href="#Getopt Long Options">Getopt Long Options</a>
+<li><code>getopt_long_only</code>: <a href="#Getopt Long Options">Getopt Long Options</a>
+<li><code>getpagesize</code>: <a href="#Query Memory Parameters">Query Memory Parameters</a>
 <li><code>getpass</code>: <a href="#getpass">getpass</a>
-<li><code>getpeername</code>: <a href="#Who%20is%20Connected">Who is Connected</a>
-<li><code>getpgid</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li><code>getpgrp</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li><code>getpid</code>: <a href="#Process%20Identification">Process Identification</a>
-<li><code>getppid</code>: <a href="#Process%20Identification">Process Identification</a>
-<li><code>getpriority</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>getprotobyname</code>: <a href="#Protocols%20Database">Protocols Database</a>
-<li><code>getprotobynumber</code>: <a href="#Protocols%20Database">Protocols Database</a>
-<li><code>getprotoent</code>: <a href="#Protocols%20Database">Protocols Database</a>
+<li><code>getpeername</code>: <a href="#Who is Connected">Who is Connected</a>
+<li><code>getpgid</code>: <a href="#Process Group Functions">Process Group Functions</a>
+<li><code>getpgrp</code>: <a href="#Process Group Functions">Process Group Functions</a>
+<li><code>getpid</code>: <a href="#Process Identification">Process Identification</a>
+<li><code>getppid</code>: <a href="#Process Identification">Process Identification</a>
+<li><code>getpriority</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>getprotobyname</code>: <a href="#Protocols Database">Protocols Database</a>
+<li><code>getprotobynumber</code>: <a href="#Protocols Database">Protocols Database</a>
+<li><code>getprotoent</code>: <a href="#Protocols Database">Protocols Database</a>
 <li><code>getpt</code>: <a href="#Allocation">Allocation</a>
-<li><code>getpwent</code>: <a href="#Scanning%20All%20Users">Scanning All Users</a>
-<li><code>getpwent_r</code>: <a href="#Scanning%20All%20Users">Scanning All Users</a>
-<li><code>getpwnam</code>: <a href="#Lookup%20User">Lookup User</a>
-<li><code>getpwnam_r</code>: <a href="#Lookup%20User">Lookup User</a>
-<li><code>getpwuid</code>: <a href="#Lookup%20User">Lookup User</a>
-<li><code>getpwuid_r</code>: <a href="#Lookup%20User">Lookup User</a>
-<li><code>getrlimit</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>getrlimit64</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>getrusage</code>: <a href="#Resource%20Usage">Resource Usage</a>
-<li><code>gets</code>: <a href="#Line%20Input">Line Input</a>
-<li><code>getservbyname</code>: <a href="#Services%20Database">Services Database</a>
-<li><code>getservbyport</code>: <a href="#Services%20Database">Services Database</a>
-<li><code>getservent</code>: <a href="#Services%20Database">Services Database</a>
-<li><code>getsid</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li><code>getsockname</code>: <a href="#Reading%20Address">Reading Address</a>
-<li><code>getsockopt</code>: <a href="#Socket%20Option%20Functions">Socket Option Functions</a>
+<li><code>getpwent</code>: <a href="#Scanning All Users">Scanning All Users</a>
+<li><code>getpwent_r</code>: <a href="#Scanning All Users">Scanning All Users</a>
+<li><code>getpwnam</code>: <a href="#Lookup User">Lookup User</a>
+<li><code>getpwnam_r</code>: <a href="#Lookup User">Lookup User</a>
+<li><code>getpwuid</code>: <a href="#Lookup User">Lookup User</a>
+<li><code>getpwuid_r</code>: <a href="#Lookup User">Lookup User</a>
+<li><code>getrlimit</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>getrlimit64</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>getrusage</code>: <a href="#Resource Usage">Resource Usage</a>
+<li><code>gets</code>: <a href="#Line Input">Line Input</a>
+<li><code>getservbyname</code>: <a href="#Services Database">Services Database</a>
+<li><code>getservbyport</code>: <a href="#Services Database">Services Database</a>
+<li><code>getservent</code>: <a href="#Services Database">Services Database</a>
+<li><code>getsid</code>: <a href="#Process Group Functions">Process Group Functions</a>
+<li><code>getsockname</code>: <a href="#Reading Address">Reading Address</a>
+<li><code>getsockopt</code>: <a href="#Socket Option Functions">Socket Option Functions</a>
 <li><code>getsubopt</code>: <a href="#Suboptions">Suboptions</a>
-<li><code>gettext</code>: <a href="#Translation%20with%20gettext">Translation with gettext</a>
-<li><code>gettimeofday</code>: <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>
-<li><code>getuid</code>: <a href="#Reading%20Persona">Reading Persona</a>
-<li><code>getumask</code>: <a href="#Setting%20Permissions">Setting Permissions</a>
-<li><code>getutent</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>getutent_r</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>getutid</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>getutid_r</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>getutline</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>getutline_r</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>getutmp</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>getutmpx</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>getutxent</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>getutxid</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>getutxline</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>getw</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getwc</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getwc_unlocked</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getwchar</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getwchar_unlocked</code>: <a href="#Character%20Input">Character Input</a>
-<li><code>getwd</code>: <a href="#Working%20Directory">Working Directory</a>
-<li><code>glob</code>: <a href="#Calling%20Glob">Calling Glob</a>
-<li><code>glob64</code>: <a href="#Calling%20Glob">Calling Glob</a>
-<li><code>globfree</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>globfree64</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>gmtime</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li><code>gmtime_r</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
+<li><code>gettext</code>: <a href="#Translation with gettext">Translation with gettext</a>
+<li><code>gettimeofday</code>: <a href="#High-Resolution Calendar">High-Resolution Calendar</a>
+<li><code>getuid</code>: <a href="#Reading Persona">Reading Persona</a>
+<li><code>getumask</code>: <a href="#Setting Permissions">Setting Permissions</a>
+<li><code>getutent</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>getutent_r</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>getutid</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>getutid_r</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>getutline</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>getutline_r</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>getutmp</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>getutmpx</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>getutxent</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>getutxid</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>getutxline</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>getw</code>: <a href="#Character Input">Character Input</a>
+<li><code>getwc</code>: <a href="#Character Input">Character Input</a>
+<li><code>getwc_unlocked</code>: <a href="#Character Input">Character Input</a>
+<li><code>getwchar</code>: <a href="#Character Input">Character Input</a>
+<li><code>getwchar_unlocked</code>: <a href="#Character Input">Character Input</a>
+<li><code>getwd</code>: <a href="#Working Directory">Working Directory</a>
+<li><code>glob</code>: <a href="#Calling Glob">Calling Glob</a>
+<li><code>glob64</code>: <a href="#Calling Glob">Calling Glob</a>
+<li><code>globfree</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>globfree64</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>gmtime</code>: <a href="#Broken-down Time">Broken-down Time</a>
+<li><code>gmtime_r</code>: <a href="#Broken-down Time">Broken-down Time</a>
 <li><code>grantpt</code>: <a href="#Allocation">Allocation</a>
-<li><code>gsignal</code>: <a href="#Signaling%20Yourself">Signaling Yourself</a>
-<li><code>gtty</code>: <a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>
+<li><code>gsignal</code>: <a href="#Signaling Yourself">Signaling Yourself</a>
+<li><code>gtty</code>: <a href="#BSD Terminal Modes">BSD Terminal Modes</a>
 <li><code>hasmntopt</code>: <a href="#mtab">mtab</a>
-<li><code>hcreate</code>: <a href="#Hash%20Search%20Function">Hash Search Function</a>
-<li><code>hcreate_r</code>: <a href="#Hash%20Search%20Function">Hash Search Function</a>
-<li><code>hdestroy</code>: <a href="#Hash%20Search%20Function">Hash Search Function</a>
-<li><code>hdestroy_r</code>: <a href="#Hash%20Search%20Function">Hash Search Function</a>
-<li><code>hsearch</code>: <a href="#Hash%20Search%20Function">Hash Search Function</a>
-<li><code>hsearch_r</code>: <a href="#Hash%20Search%20Function">Hash Search Function</a>
-<li><code>htonl</code>: <a href="#Byte%20Order">Byte Order</a>
-<li><code>htons</code>: <a href="#Byte%20Order">Byte Order</a>
-<li><code>hypot</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>hypotf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>hypotl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>iconv</code>: <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>
-<li><code>iconv_close</code>: <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>
-<li><code>iconv_open</code>: <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>
-<li><code>if_freenameindex</code>: <a href="#Interface%20Naming">Interface Naming</a>
-<li><code>if_indextoname</code>: <a href="#Interface%20Naming">Interface Naming</a>
-<li><code>if_nameindex</code>: <a href="#Interface%20Naming">Interface Naming</a>
-<li><code>if_nametoindex</code>: <a href="#Interface%20Naming">Interface Naming</a>
-<li><code>IFTODT</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>ilogb</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>ilogbf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>ilogbl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>imaxabs</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>imaxdiv</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>index</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>inet_addr</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_aton</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_lnaof</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_makeaddr</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_netof</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_network</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_ntoa</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_ntop</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>inet_pton</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>initgroups</code>: <a href="#Setting%20Groups">Setting Groups</a>
-<li><code>initstate</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>initstate_r</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>innetgr</code>: <a href="#Netgroup%20Membership">Netgroup Membership</a>
+<li><code>hcreate</code>: <a href="#Hash Search Function">Hash Search Function</a>
+<li><code>hcreate_r</code>: <a href="#Hash Search Function">Hash Search Function</a>
+<li><code>hdestroy</code>: <a href="#Hash Search Function">Hash Search Function</a>
+<li><code>hdestroy_r</code>: <a href="#Hash Search Function">Hash Search Function</a>
+<li><code>hsearch</code>: <a href="#Hash Search Function">Hash Search Function</a>
+<li><code>hsearch_r</code>: <a href="#Hash Search Function">Hash Search Function</a>
+<li><code>htonl</code>: <a href="#Byte Order">Byte Order</a>
+<li><code>htons</code>: <a href="#Byte Order">Byte Order</a>
+<li><code>hypot</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>hypotf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>hypotl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>iconv</code>: <a href="#Generic Conversion Interface">Generic Conversion Interface</a>
+<li><code>iconv_close</code>: <a href="#Generic Conversion Interface">Generic Conversion Interface</a>
+<li><code>iconv_open</code>: <a href="#Generic Conversion Interface">Generic Conversion Interface</a>
+<li><code>if_freenameindex</code>: <a href="#Interface Naming">Interface Naming</a>
+<li><code>if_indextoname</code>: <a href="#Interface Naming">Interface Naming</a>
+<li><code>if_nameindex</code>: <a href="#Interface Naming">Interface Naming</a>
+<li><code>if_nametoindex</code>: <a href="#Interface Naming">Interface Naming</a>
+<li><code>IFTODT</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>ilogb</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>ilogbf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>ilogbl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>imaxabs</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>imaxdiv</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>index</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>inet_addr</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_aton</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_lnaof</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_makeaddr</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_netof</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_network</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_ntoa</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_ntop</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>inet_pton</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>initgroups</code>: <a href="#Setting Groups">Setting Groups</a>
+<li><code>initstate</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>initstate_r</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>innetgr</code>: <a href="#Netgroup Membership">Netgroup Membership</a>
 <li><code>ioctl</code>: <a href="#IOCTLs">IOCTLs</a>
-<li><code>isalnum</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isalpha</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isascii</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isatty</code>: <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>
-<li><code>isblank</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>iscntrl</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isdigit</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isfinite</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isgraph</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isgreater</code>: <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>
-<li><code>isgreaterequal</code>: <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>
-<li><code>isinf</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isinff</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isinfl</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isless</code>: <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>
-<li><code>islessequal</code>: <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>
-<li><code>islessgreater</code>: <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>
-<li><code>islower</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isnan</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isnanf</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isnanl</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isnormal</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>isprint</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>ispunct</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isspace</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>isunordered</code>: <a href="#FP%20Comparison%20Functions">FP Comparison Functions</a>
-<li><code>isupper</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>iswalnum</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswalpha</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswblank</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswcntrl</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswctype</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswdigit</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswgraph</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswlower</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswprint</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswpunct</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswspace</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswupper</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>iswxdigit</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>isxdigit</code>: <a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><code>j0</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>j0f</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>j0l</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>j1</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>j1f</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>j1l</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>jn</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>jnf</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>jnl</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>jrand48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>jrand48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>kill</code>: <a href="#Signaling%20Another%20Process">Signaling Another Process</a>
-<li><code>killpg</code>: <a href="#Signaling%20Another%20Process">Signaling Another Process</a>
-<li><code>l64a</code>: <a href="#Encode%20Binary%20Data">Encode Binary Data</a>
-<li><code>labs</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>lcong48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>lcong48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>ldexp</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>ldexpf</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>ldexpl</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>ldiv</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>lfind</code>: <a href="#Array%20Search%20Function">Array Search Function</a>
-<li><code>lgamma</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>lgamma_r</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>lgammaf</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>lgammaf_r</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>lgammal</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>lgammal_r</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>link</code>: <a href="#Hard%20Links">Hard Links</a>
-<li><code>lio_listio</code>: <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>
-<li><code>lio_listio64</code>: <a href="#Asynchronous%20Reads%2fWrites">Asynchronous Reads/Writes</a>
+<li><code>isalnum</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isalpha</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isascii</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isatty</code>: <a href="#Is It a Terminal">Is It a Terminal</a>
+<li><code>isblank</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>iscntrl</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isdigit</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isfinite</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isgraph</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isgreater</code>: <a href="#FP Comparison Functions">FP Comparison Functions</a>
+<li><code>isgreaterequal</code>: <a href="#FP Comparison Functions">FP Comparison Functions</a>
+<li><code>isinf</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isinff</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isinfl</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isless</code>: <a href="#FP Comparison Functions">FP Comparison Functions</a>
+<li><code>islessequal</code>: <a href="#FP Comparison Functions">FP Comparison Functions</a>
+<li><code>islessgreater</code>: <a href="#FP Comparison Functions">FP Comparison Functions</a>
+<li><code>islower</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isnan</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isnanf</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isnanl</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isnormal</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>isprint</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>ispunct</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isspace</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>isunordered</code>: <a href="#FP Comparison Functions">FP Comparison Functions</a>
+<li><code>isupper</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>iswalnum</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswalpha</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswblank</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswcntrl</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswctype</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswdigit</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswgraph</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswlower</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswprint</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswpunct</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswspace</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswupper</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>iswxdigit</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>isxdigit</code>: <a href="#Classification of Characters">Classification of Characters</a>
+<li><code>j0</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>j0f</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>j0l</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>j1</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>j1f</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>j1l</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>jn</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>jnf</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>jnl</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>jrand48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>jrand48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>kill</code>: <a href="#Signaling Another Process">Signaling Another Process</a>
+<li><code>killpg</code>: <a href="#Signaling Another Process">Signaling Another Process</a>
+<li><code>l64a</code>: <a href="#Encode Binary Data">Encode Binary Data</a>
+<li><code>labs</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>lcong48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>lcong48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>ldexp</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>ldexpf</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>ldexpl</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>ldiv</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>lfind</code>: <a href="#Array Search Function">Array Search Function</a>
+<li><code>lgamma</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>lgamma_r</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>lgammaf</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>lgammaf_r</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>lgammal</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>lgammal_r</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>link</code>: <a href="#Hard Links">Hard Links</a>
+<li><code>lio_listio</code>: <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>
+<li><code>lio_listio64</code>: <a href="#Asynchronous Reads%2fWrites">Asynchronous Reads/Writes</a>
 <li><code>listen</code>: <a href="#Listening">Listening</a>
-<li><code>llabs</code>: <a href="#Absolute%20Value">Absolute Value</a>
-<li><code>lldiv</code>: <a href="#Integer%20Division">Integer Division</a>
-<li><code>llrint</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>llrintf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>llrintl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>llround</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>llroundf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>llroundl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>localeconv</code>: <a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>
-<li><code>localtime</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li><code>localtime_r</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li><code>log</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log10</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log10f</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log10l</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log1p</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log1pf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log1pl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log2</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log2f</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>log2l</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>logb</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>logbf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>logbl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>logf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>login</code>: <a href="#Logging%20In%20and%20Out">Logging In and Out</a>
-<li><code>login_tty</code>: <a href="#Logging%20In%20and%20Out">Logging In and Out</a>
-<li><code>logl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>logout</code>: <a href="#Logging%20In%20and%20Out">Logging In and Out</a>
-<li><code>logwtmp</code>: <a href="#Logging%20In%20and%20Out">Logging In and Out</a>
-<li><code>longjmp</code>: <a href="#Non-Local%20Details">Non-Local Details</a>
-<li><code>lrand48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>lrand48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>lrint</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>lrintf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>lrintl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>lround</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>lroundf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>lroundl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>lsearch</code>: <a href="#Array%20Search%20Function">Array Search Function</a>
-<li><code>lseek</code>: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li><code>lseek64</code>: <a href="#File%20Position%20Primitive">File Position Primitive</a>
-<li><code>lstat</code>: <a href="#Reading%20Attributes">Reading Attributes</a>
-<li><code>lstat64</code>: <a href="#Reading%20Attributes">Reading Attributes</a>
-<li><code>madvise</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>main</code>: <a href="#Program%20Arguments">Program Arguments</a>
-<li><code>makecontext</code>: <a href="#System%20V%20contexts">System V contexts</a>
-<li><code>mallinfo</code>: <a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>
-<li><code>malloc</code>: <a href="#Basic%20Allocation">Basic Allocation</a>
-<li><code>mallopt</code>: <a href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>
-<li><code>matherr</code>: <a href="#FP%20Exceptions">FP Exceptions</a>
-<li><code>mblen</code>: <a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>
-<li><code>mbrlen</code>: <a href="#Converting%20a%20Character">Converting a Character</a>
-<li><code>mbrtowc</code>: <a href="#Converting%20a%20Character">Converting a Character</a>
-<li><code>mbsinit</code>: <a href="#Keeping%20the%20state">Keeping the state</a>
-<li><code>mbsnrtowcs</code>: <a href="#Converting%20Strings">Converting Strings</a>
-<li><code>mbsrtowcs</code>: <a href="#Converting%20Strings">Converting Strings</a>
-<li><code>mbstowcs</code>: <a href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>
-<li><code>mbtowc</code>: <a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>
-<li><code>mcheck</code>: <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>
-<li><code>memalign</code>: <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>
-<li><code>memccpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>memchr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>memcmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>memcpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>memfrob</code>: <a href="#Trivial%20Encryption">Trivial Encryption</a>
-<li><code>memmem</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>memmove</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>mempcpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>memrchr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>memset</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>mkdir</code>: <a href="#Creating%20Directories">Creating Directories</a>
-<li><code>mkdtemp</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>mkfifo</code>: <a href="#FIFO%20Special%20Files">FIFO Special Files</a>
-<li><code>mknod</code>: <a href="#Making%20Special%20Files">Making Special Files</a>
-<li><code>mkstemp</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>mktemp</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>mktime</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li><code>mlock</code>: <a href="#Page%20Lock%20Functions">Page Lock Functions</a>
-<li><code>mlockall</code>: <a href="#Page%20Lock%20Functions">Page Lock Functions</a>
-<li><code>mmap</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>mmap64</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>modf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>modff</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>modfl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
+<li><code>llabs</code>: <a href="#Absolute Value">Absolute Value</a>
+<li><code>lldiv</code>: <a href="#Integer Division">Integer Division</a>
+<li><code>llrint</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>llrintf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>llrintl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>llround</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>llroundf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>llroundl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>localeconv</code>: <a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>
+<li><code>localtime</code>: <a href="#Broken-down Time">Broken-down Time</a>
+<li><code>localtime_r</code>: <a href="#Broken-down Time">Broken-down Time</a>
+<li><code>log</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log10</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log10f</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log10l</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log1p</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log1pf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log1pl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log2</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log2f</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>log2l</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>logb</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>logbf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>logbl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>logf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>login</code>: <a href="#Logging In and Out">Logging In and Out</a>
+<li><code>login_tty</code>: <a href="#Logging In and Out">Logging In and Out</a>
+<li><code>logl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>logout</code>: <a href="#Logging In and Out">Logging In and Out</a>
+<li><code>logwtmp</code>: <a href="#Logging In and Out">Logging In and Out</a>
+<li><code>longjmp</code>: <a href="#Non-Local Details">Non-Local Details</a>
+<li><code>lrand48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>lrand48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>lrint</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>lrintf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>lrintl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>lround</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>lroundf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>lroundl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>lsearch</code>: <a href="#Array Search Function">Array Search Function</a>
+<li><code>lseek</code>: <a href="#File Position Primitive">File Position Primitive</a>
+<li><code>lseek64</code>: <a href="#File Position Primitive">File Position Primitive</a>
+<li><code>lstat</code>: <a href="#Reading Attributes">Reading Attributes</a>
+<li><code>lstat64</code>: <a href="#Reading Attributes">Reading Attributes</a>
+<li><code>madvise</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>main</code>: <a href="#Program Arguments">Program Arguments</a>
+<li><code>makecontext</code>: <a href="#System V contexts">System V contexts</a>
+<li><code>mallinfo</code>: <a href="#Statistics of Malloc">Statistics of Malloc</a>
+<li><code>malloc</code>: <a href="#Basic Allocation">Basic Allocation</a>
+<li><code>mallopt</code>: <a href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>
+<li><code>matherr</code>: <a href="#FP Exceptions">FP Exceptions</a>
+<li><code>mblen</code>: <a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>
+<li><code>mbrlen</code>: <a href="#Converting a Character">Converting a Character</a>
+<li><code>mbrtowc</code>: <a href="#Converting a Character">Converting a Character</a>
+<li><code>mbsinit</code>: <a href="#Keeping the state">Keeping the state</a>
+<li><code>mbsnrtowcs</code>: <a href="#Converting Strings">Converting Strings</a>
+<li><code>mbsrtowcs</code>: <a href="#Converting Strings">Converting Strings</a>
+<li><code>mbstowcs</code>: <a href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>
+<li><code>mbtowc</code>: <a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>
+<li><code>mcheck</code>: <a href="#Heap Consistency Checking">Heap Consistency Checking</a>
+<li><code>memalign</code>: <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>
+<li><code>memccpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>memchr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>memcmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>memcpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>memfrob</code>: <a href="#Trivial Encryption">Trivial Encryption</a>
+<li><code>memmem</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>memmove</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>mempcpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>memrchr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>memset</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>mkdir</code>: <a href="#Creating Directories">Creating Directories</a>
+<li><code>mkdtemp</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>mkfifo</code>: <a href="#FIFO Special Files">FIFO Special Files</a>
+<li><code>mknod</code>: <a href="#Making Special Files">Making Special Files</a>
+<li><code>mkstemp</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>mktemp</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>mktime</code>: <a href="#Broken-down Time">Broken-down Time</a>
+<li><code>mlock</code>: <a href="#Page Lock Functions">Page Lock Functions</a>
+<li><code>mlockall</code>: <a href="#Page Lock Functions">Page Lock Functions</a>
+<li><code>mmap</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>mmap64</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>modf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>modff</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>modfl</code>: <a href="#Rounding Functions">Rounding Functions</a>
 <li><code>mount</code>: <a href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>
-<li><code>mprobe</code>: <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>
-<li><code>mrand48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>mrand48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>mremap</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>msync</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>mtrace</code>: <a href="#Tracing%20malloc">Tracing malloc</a>
-<li><code>munlock</code>: <a href="#Page%20Lock%20Functions">Page Lock Functions</a>
-<li><code>munlockall</code>: <a href="#Page%20Lock%20Functions">Page Lock Functions</a>
-<li><code>munmap</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>muntrace</code>: <a href="#Tracing%20malloc">Tracing malloc</a>
-<li><code>nan</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nanf</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nanl</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
+<li><code>mprobe</code>: <a href="#Heap Consistency Checking">Heap Consistency Checking</a>
+<li><code>mrand48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>mrand48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>mremap</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>msync</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>mtrace</code>: <a href="#Tracing malloc">Tracing malloc</a>
+<li><code>munlock</code>: <a href="#Page Lock Functions">Page Lock Functions</a>
+<li><code>munlockall</code>: <a href="#Page Lock Functions">Page Lock Functions</a>
+<li><code>munmap</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>muntrace</code>: <a href="#Tracing malloc">Tracing malloc</a>
+<li><code>nan</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nanf</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nanl</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
 <li><code>nanosleep</code>: <a href="#Sleeping">Sleeping</a>
-<li><code>nearbyint</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>nearbyintf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>nearbyintl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>nextafter</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nextafterf</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nextafterl</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nexttoward</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nexttowardf</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nexttowardl</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>nftw</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>nftw64</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>ngettext</code>: <a href="#Advanced%20gettext%20functions">Advanced gettext functions</a>
-<li><code>nice</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>nl_langinfo</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>notfound</code>: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li><code>nrand48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>nrand48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>ntohl</code>: <a href="#Byte%20Order">Byte Order</a>
-<li><code>ntohs</code>: <a href="#Byte%20Order">Byte Order</a>
-<li><code>ntp_adjtime</code>: <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li><code>ntp_gettime</code>: <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li><code>obstack_1grow</code>: <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_1grow_fast</code>: <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>
-<li><code>obstack_alignment_mask</code>: <a href="#Obstacks%20Data%20Alignment">Obstacks Data Alignment</a>
-<li><code>obstack_alloc</code>: <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>
-<li><code>obstack_base</code>: <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>
-<li><code>obstack_blank</code>: <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_blank_fast</code>: <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>
-<li><code>obstack_chunk_alloc</code>: <a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>
-<li><code>obstack_chunk_free</code>: <a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>
-<li><code>obstack_chunk_size</code>: <a href="#Obstack%20Chunks">Obstack Chunks</a>
-<li><code>obstack_copy</code>: <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>
-<li><code>obstack_copy0</code>: <a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>
-<li><code>obstack_finish</code>: <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_free</code>: <a href="#Freeing%20Obstack%20Objects">Freeing Obstack Objects</a>
-<li><code>obstack_grow</code>: <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_grow0</code>: <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_init</code>: <a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>
-<li><code>obstack_int_grow</code>: <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_int_grow_fast</code>: <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>
-<li><code>obstack_next_free</code>: <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>
-<li><code>obstack_object_size</code>: <a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>, <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_printf</code>: <a href="#Dynamic%20Output">Dynamic Output</a>
-<li><code>obstack_ptr_grow</code>: <a href="#Growing%20Objects">Growing Objects</a>
-<li><code>obstack_ptr_grow_fast</code>: <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>
-<li><code>obstack_room</code>: <a href="#Extra%20Fast%20Growing">Extra Fast Growing</a>
-<li><code>obstack_vprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>offsetof</code>: <a href="#Structure%20Measurement">Structure Measurement</a>
-<li><code>on_exit</code>: <a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>
-<li><code>open</code>: <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li><code>open64</code>: <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li><code>open_memstream</code>: <a href="#String%20Streams">String Streams</a>
-<li><code>open_obstack_stream</code>: <a href="#Obstack%20Streams">Obstack Streams</a>
-<li><code>opendir</code>: <a href="#Opening%20a%20Directory">Opening a Directory</a>
+<li><code>nearbyint</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>nearbyintf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>nearbyintl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>nextafter</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nextafterf</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nextafterl</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nexttoward</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nexttowardf</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nexttowardl</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>nftw</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>nftw64</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>ngettext</code>: <a href="#Advanced gettext functions">Advanced gettext functions</a>
+<li><code>nice</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>nl_langinfo</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>notfound</code>: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li><code>nrand48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>nrand48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>ntohl</code>: <a href="#Byte Order">Byte Order</a>
+<li><code>ntohs</code>: <a href="#Byte Order">Byte Order</a>
+<li><code>ntp_adjtime</code>: <a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li><code>ntp_gettime</code>: <a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li><code>obstack_1grow</code>: <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_1grow_fast</code>: <a href="#Extra Fast Growing">Extra Fast Growing</a>
+<li><code>obstack_alignment_mask</code>: <a href="#Obstacks Data Alignment">Obstacks Data Alignment</a>
+<li><code>obstack_alloc</code>: <a href="#Allocation in an Obstack">Allocation in an Obstack</a>
+<li><code>obstack_base</code>: <a href="#Status of an Obstack">Status of an Obstack</a>
+<li><code>obstack_blank</code>: <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_blank_fast</code>: <a href="#Extra Fast Growing">Extra Fast Growing</a>
+<li><code>obstack_chunk_alloc</code>: <a href="#Preparing for Obstacks">Preparing for Obstacks</a>
+<li><code>obstack_chunk_free</code>: <a href="#Preparing for Obstacks">Preparing for Obstacks</a>
+<li><code>obstack_chunk_size</code>: <a href="#Obstack Chunks">Obstack Chunks</a>
+<li><code>obstack_copy</code>: <a href="#Allocation in an Obstack">Allocation in an Obstack</a>
+<li><code>obstack_copy0</code>: <a href="#Allocation in an Obstack">Allocation in an Obstack</a>
+<li><code>obstack_finish</code>: <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_free</code>: <a href="#Freeing Obstack Objects">Freeing Obstack Objects</a>
+<li><code>obstack_grow</code>: <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_grow0</code>: <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_init</code>: <a href="#Preparing for Obstacks">Preparing for Obstacks</a>
+<li><code>obstack_int_grow</code>: <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_int_grow_fast</code>: <a href="#Extra Fast Growing">Extra Fast Growing</a>
+<li><code>obstack_next_free</code>: <a href="#Status of an Obstack">Status of an Obstack</a>
+<li><code>obstack_object_size</code>: <a href="#Status of an Obstack">Status of an Obstack</a>, <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_printf</code>: <a href="#Dynamic Output">Dynamic Output</a>
+<li><code>obstack_ptr_grow</code>: <a href="#Growing Objects">Growing Objects</a>
+<li><code>obstack_ptr_grow_fast</code>: <a href="#Extra Fast Growing">Extra Fast Growing</a>
+<li><code>obstack_room</code>: <a href="#Extra Fast Growing">Extra Fast Growing</a>
+<li><code>obstack_vprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>offsetof</code>: <a href="#Structure Measurement">Structure Measurement</a>
+<li><code>on_exit</code>: <a href="#Cleanups on Exit">Cleanups on Exit</a>
+<li><code>open</code>: <a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li><code>open64</code>: <a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li><code>open_memstream</code>: <a href="#String Streams">String Streams</a>
+<li><code>open_obstack_stream</code>: <a href="#Obstack Streams">Obstack Streams</a>
+<li><code>opendir</code>: <a href="#Opening a Directory">Opening a Directory</a>
 <li><code>openlog</code>: <a href="#openlog">openlog</a>
-<li><code>openpty</code>: <a href="#Pseudo-Terminal%20Pairs">Pseudo-Terminal Pairs</a>
-<li><code>parse_printf_format</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
+<li><code>openpty</code>: <a href="#Pseudo-Terminal Pairs">Pseudo-Terminal Pairs</a>
+<li><code>parse_printf_format</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
 <li><code>pathconf</code>: <a href="#Pathconf">Pathconf</a>
-<li><code>pause</code>: <a href="#Using%20Pause">Using Pause</a>
-<li><code>pclose</code>: <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>
-<li><code>perror</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>pipe</code>: <a href="#Creating%20a%20Pipe">Creating a Pipe</a>
-<li><code>popen</code>: <a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>
-<li><code>posix_memalign</code>: <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>
-<li><code>pow</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>pow10</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>pow10f</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>pow10l</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>powf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>powl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>pread</code>: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li><code>pread64</code>: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li><code>printf</code>: <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><code>printf_size</code>: <a href="#Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>
-<li><code>printf_size_info</code>: <a href="#Predefined%20Printf%20Handlers">Predefined Printf Handlers</a>
-<li><code>psignal</code>: <a href="#Signal%20Messages">Signal Messages</a>
+<li><code>pause</code>: <a href="#Using Pause">Using Pause</a>
+<li><code>pclose</code>: <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>
+<li><code>perror</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>pipe</code>: <a href="#Creating a Pipe">Creating a Pipe</a>
+<li><code>popen</code>: <a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>
+<li><code>posix_memalign</code>: <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>
+<li><code>pow</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>pow10</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>pow10f</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>pow10l</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>powf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>powl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>pread</code>: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li><code>pread64</code>: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li><code>printf</code>: <a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><code>printf_size</code>: <a href="#Predefined Printf Handlers">Predefined Printf Handlers</a>
+<li><code>printf_size_info</code>: <a href="#Predefined Printf Handlers">Predefined Printf Handlers</a>
+<li><code>psignal</code>: <a href="#Signal Messages">Signal Messages</a>
 <li><code>ptsname</code>: <a href="#Allocation">Allocation</a>
 <li><code>ptsname_r</code>: <a href="#Allocation">Allocation</a>
-<li><code>putc</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putc_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putchar</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putchar_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putenv</code>: <a href="#Environment%20Access">Environment Access</a>
-<li><code>putpwent</code>: <a href="#Writing%20a%20User%20Entry">Writing a User Entry</a>
-<li><code>puts</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>pututline</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>pututxline</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>putw</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putwc</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putwc_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putwchar</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>putwchar_unlocked</code>: <a href="#Simple%20Output">Simple Output</a>
-<li><code>pwrite</code>: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li><code>pwrite64</code>: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li><code>qecvt</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>qecvt_r</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>qfcvt</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>qfcvt_r</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>qgcvt</code>: <a href="#System%20V%20Number%20Conversion">System V Number Conversion</a>
-<li><code>qsort</code>: <a href="#Array%20Sort%20Function">Array Sort Function</a>
-<li><code>raise</code>: <a href="#Signaling%20Yourself">Signaling Yourself</a>
-<li><code>rand</code>: <a href="#ISO%20Random">ISO Random</a>
-<li><code>rand_r</code>: <a href="#ISO%20Random">ISO Random</a>
-<li><code>random</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>random_r</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>rawmemchr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>read</code>: <a href="#I%2fO%20Primitives">I/O Primitives</a>
-<li><code>readdir</code>: <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>
-<li><code>readdir64</code>: <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>
-<li><code>readdir64_r</code>: <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>
-<li><code>readdir_r</code>: <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>
-<li><code>readlink</code>: <a href="#Symbolic%20Links">Symbolic Links</a>
+<li><code>putc</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putc_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putchar</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putchar_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putenv</code>: <a href="#Environment Access">Environment Access</a>
+<li><code>putpwent</code>: <a href="#Writing a User Entry">Writing a User Entry</a>
+<li><code>puts</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>pututline</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>pututxline</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>putw</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putwc</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putwc_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putwchar</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>putwchar_unlocked</code>: <a href="#Simple Output">Simple Output</a>
+<li><code>pwrite</code>: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li><code>pwrite64</code>: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li><code>qecvt</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>qecvt_r</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>qfcvt</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>qfcvt_r</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>qgcvt</code>: <a href="#System V Number Conversion">System V Number Conversion</a>
+<li><code>qsort</code>: <a href="#Array Sort Function">Array Sort Function</a>
+<li><code>raise</code>: <a href="#Signaling Yourself">Signaling Yourself</a>
+<li><code>rand</code>: <a href="#ISO Random">ISO Random</a>
+<li><code>rand_r</code>: <a href="#ISO Random">ISO Random</a>
+<li><code>random</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>random_r</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>rawmemchr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>read</code>: <a href="#I%2fO Primitives">I/O Primitives</a>
+<li><code>readdir</code>: <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>
+<li><code>readdir64</code>: <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>
+<li><code>readdir64_r</code>: <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>
+<li><code>readdir_r</code>: <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>
+<li><code>readlink</code>: <a href="#Symbolic Links">Symbolic Links</a>
 <li><code>readv</code>: <a href="#Scatter-Gather">Scatter-Gather</a>
-<li><code>realloc</code>: <a href="#Changing%20Block%20Size">Changing Block Size</a>
-<li><code>realpath</code>: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li><code>recv</code>: <a href="#Receiving%20Data">Receiving Data</a>
-<li><code>recvfrom</code>: <a href="#Receiving%20Datagrams">Receiving Datagrams</a>
-<li><code>regcomp</code>: <a href="#POSIX%20Regexp%20Compilation">POSIX Regexp Compilation</a>
-<li><code>regerror</code>: <a href="#Regexp%20Cleanup">Regexp Cleanup</a>
-<li><code>regexec</code>: <a href="#Matching%20POSIX%20Regexps">Matching POSIX Regexps</a>
-<li><code>regfree</code>: <a href="#Regexp%20Cleanup">Regexp Cleanup</a>
-<li><code>register_printf_function</code>: <a href="#Registering%20New%20Conversions">Registering New Conversions</a>
-<li><code>remainder</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>remainderf</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>remainderl</code>: <a href="#Remainder%20Functions">Remainder Functions</a>
-<li><code>remove</code>: <a href="#Deleting%20Files">Deleting Files</a>
-<li><code>rename</code>: <a href="#Renaming%20Files">Renaming Files</a>
-<li><code>rewind</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>rewinddir</code>: <a href="#Random%20Access%20Directory">Random Access Directory</a>
-<li><code>rindex</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>rint</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>rintf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>rintl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>rmdir</code>: <a href="#Deleting%20Files">Deleting Files</a>
-<li><code>round</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>roundf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>roundl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>rpmatch</code>: <a href="#Yes-or-No%20Questions">Yes-or-No Questions</a>
-<li><code>S_ISBLK</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_ISCHR</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_ISDIR</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_ISFIFO</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_ISLNK</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_ISREG</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_ISSOCK</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_TYPEISMQ</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_TYPEISSEM</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_TYPEISSHM</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>sbrk</code>: <a href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>
-<li><code>scalb</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalbf</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalbl</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalbln</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalblnf</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalblnl</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalbn</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalbnf</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scalbnl</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>scandir</code>: <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>
-<li><code>scandir64</code>: <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>
-<li><code>scanf</code>: <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>
-<li><code>sched_get_priority_max</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>sched_get_priority_min</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>sched_getparam</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>sched_getscheduler</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>sched_rr_get_interval</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>sched_setparam</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>sched_setscheduler</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>sched_yield</code>: <a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><code>seed48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>seed48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>seekdir</code>: <a href="#Random%20Access%20Directory">Random Access Directory</a>
-<li><code>select</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li><code>send</code>: <a href="#Sending%20Data">Sending Data</a>
-<li><code>sendto</code>: <a href="#Sending%20Datagrams">Sending Datagrams</a>
-<li><code>setbuf</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>setbuffer</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>setcontext</code>: <a href="#System%20V%20contexts">System V contexts</a>
-<li><code>setdomainname</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>setegid</code>: <a href="#Setting%20Groups">Setting Groups</a>
-<li><code>setenv</code>: <a href="#Environment%20Access">Environment Access</a>
-<li><code>seteuid</code>: <a href="#Setting%20User%20ID">Setting User ID</a>
+<li><code>realloc</code>: <a href="#Changing Block Size">Changing Block Size</a>
+<li><code>realpath</code>: <a href="#Symbolic Links">Symbolic Links</a>
+<li><code>recv</code>: <a href="#Receiving Data">Receiving Data</a>
+<li><code>recvfrom</code>: <a href="#Receiving Datagrams">Receiving Datagrams</a>
+<li><code>regcomp</code>: <a href="#POSIX Regexp Compilation">POSIX Regexp Compilation</a>
+<li><code>regerror</code>: <a href="#Regexp Cleanup">Regexp Cleanup</a>
+<li><code>regexec</code>: <a href="#Matching POSIX Regexps">Matching POSIX Regexps</a>
+<li><code>regfree</code>: <a href="#Regexp Cleanup">Regexp Cleanup</a>
+<li><code>register_printf_function</code>: <a href="#Registering New Conversions">Registering New Conversions</a>
+<li><code>remainder</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>remainderf</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>remainderl</code>: <a href="#Remainder Functions">Remainder Functions</a>
+<li><code>remove</code>: <a href="#Deleting Files">Deleting Files</a>
+<li><code>rename</code>: <a href="#Renaming Files">Renaming Files</a>
+<li><code>rewind</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>rewinddir</code>: <a href="#Random Access Directory">Random Access Directory</a>
+<li><code>rindex</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>rint</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>rintf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>rintl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>rmdir</code>: <a href="#Deleting Files">Deleting Files</a>
+<li><code>round</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>roundf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>roundl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>rpmatch</code>: <a href="#Yes-or-No Questions">Yes-or-No Questions</a>
+<li><code>S_ISBLK</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_ISCHR</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_ISDIR</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_ISFIFO</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_ISLNK</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_ISREG</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_ISSOCK</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_TYPEISMQ</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_TYPEISSEM</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_TYPEISSHM</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>sbrk</code>: <a href="#Resizing the Data Segment">Resizing the Data Segment</a>
+<li><code>scalb</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalbf</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalbl</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalbln</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalblnf</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalblnl</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalbn</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalbnf</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scalbnl</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>scandir</code>: <a href="#Scanning Directory Content">Scanning Directory Content</a>
+<li><code>scandir64</code>: <a href="#Scanning Directory Content">Scanning Directory Content</a>
+<li><code>scanf</code>: <a href="#Formatted Input Functions">Formatted Input Functions</a>
+<li><code>sched_get_priority_max</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>sched_get_priority_min</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>sched_getparam</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>sched_getscheduler</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>sched_rr_get_interval</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>sched_setparam</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>sched_setscheduler</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>sched_yield</code>: <a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><code>seed48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>seed48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>seekdir</code>: <a href="#Random Access Directory">Random Access Directory</a>
+<li><code>select</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li><code>send</code>: <a href="#Sending Data">Sending Data</a>
+<li><code>sendto</code>: <a href="#Sending Datagrams">Sending Datagrams</a>
+<li><code>setbuf</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>setbuffer</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>setcontext</code>: <a href="#System V contexts">System V contexts</a>
+<li><code>setdomainname</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>setegid</code>: <a href="#Setting Groups">Setting Groups</a>
+<li><code>setenv</code>: <a href="#Environment Access">Environment Access</a>
+<li><code>seteuid</code>: <a href="#Setting User ID">Setting User ID</a>
 <li><code>setfsent</code>: <a href="#fstab">fstab</a>
-<li><code>setgid</code>: <a href="#Setting%20Groups">Setting Groups</a>
-<li><code>setgrent</code>: <a href="#Scanning%20All%20Groups">Scanning All Groups</a>
-<li><code>setgroups</code>: <a href="#Setting%20Groups">Setting Groups</a>
-<li><code>sethostent</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>sethostid</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>sethostname</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>setitimer</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>setjmp</code>: <a href="#Non-Local%20Details">Non-Local Details</a>
-<li><code>setkey</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>setkey_r</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>setlinebuf</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>setlocale</code>: <a href="#Setting%20the%20Locale">Setting the Locale</a>
+<li><code>setgid</code>: <a href="#Setting Groups">Setting Groups</a>
+<li><code>setgrent</code>: <a href="#Scanning All Groups">Scanning All Groups</a>
+<li><code>setgroups</code>: <a href="#Setting Groups">Setting Groups</a>
+<li><code>sethostent</code>: <a href="#Host Names">Host Names</a>
+<li><code>sethostid</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>sethostname</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>setitimer</code>: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>setjmp</code>: <a href="#Non-Local Details">Non-Local Details</a>
+<li><code>setkey</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>setkey_r</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>setlinebuf</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>setlocale</code>: <a href="#Setting the Locale">Setting the Locale</a>
 <li><code>setlogmask</code>: <a href="#setlogmask">setlogmask</a>
 <li><code>setmntent</code>: <a href="#mtab">mtab</a>
-<li><code>setnetent</code>: <a href="#Networks%20Database">Networks Database</a>
-<li><code>setnetgrent</code>: <a href="#Lookup%20Netgroup">Lookup Netgroup</a>
-<li><code>setpgid</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li><code>setpgrp</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li><code>setpriority</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>setprotoent</code>: <a href="#Protocols%20Database">Protocols Database</a>
-<li><code>setpwent</code>: <a href="#Scanning%20All%20Users">Scanning All Users</a>
-<li><code>setregid</code>: <a href="#Setting%20Groups">Setting Groups</a>
-<li><code>setreuid</code>: <a href="#Setting%20User%20ID">Setting User ID</a>
-<li><code>setrlimit</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>setrlimit64</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>setservent</code>: <a href="#Services%20Database">Services Database</a>
-<li><code>setsid</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li><code>setsockopt</code>: <a href="#Socket%20Option%20Functions">Socket Option Functions</a>
-<li><code>setstate</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>setstate_r</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>settimeofday</code>: <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>
-<li><code>setuid</code>: <a href="#Setting%20User%20ID">Setting User ID</a>
-<li><code>setutent</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>setutxent</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>setvbuf</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>shutdown</code>: <a href="#Closing%20a%20Socket">Closing a Socket</a>
-<li><code>sigaction</code>: <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>
-<li><code>sigaddset</code>: <a href="#Signal%20Sets">Signal Sets</a>
-<li><code>sigaltstack</code>: <a href="#Signal%20Stack">Signal Stack</a>
-<li><code>sigblock</code>: <a href="#Blocking%20in%20BSD">Blocking in BSD</a>
-<li><code>sigdelset</code>: <a href="#Signal%20Sets">Signal Sets</a>
-<li><code>sigemptyset</code>: <a href="#Signal%20Sets">Signal Sets</a>
-<li><code>sigfillset</code>: <a href="#Signal%20Sets">Signal Sets</a>
-<li><code>siginterrupt</code>: <a href="#BSD%20Handler">BSD Handler</a>
-<li><code>sigismember</code>: <a href="#Signal%20Sets">Signal Sets</a>
-<li><code>siglongjmp</code>: <a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>
-<li><code>sigmask</code>: <a href="#Blocking%20in%20BSD">Blocking in BSD</a>
-<li><code>signal</code>: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><code>signbit</code>: <a href="#FP%20Bit%20Twiddling">FP Bit Twiddling</a>
-<li><code>significand</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>significandf</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>significandl</code>: <a href="#Normalization%20Functions">Normalization Functions</a>
-<li><code>sigpause</code>: <a href="#Blocking%20in%20BSD">Blocking in BSD</a>
-<li><code>sigpending</code>: <a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>
-<li><code>sigprocmask</code>: <a href="#Process%20Signal%20Mask">Process Signal Mask</a>
-<li><code>sigsetjmp</code>: <a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>
-<li><code>sigsetmask</code>: <a href="#Blocking%20in%20BSD">Blocking in BSD</a>
-<li><code>sigstack</code>: <a href="#Signal%20Stack">Signal Stack</a>
+<li><code>setnetent</code>: <a href="#Networks Database">Networks Database</a>
+<li><code>setnetgrent</code>: <a href="#Lookup Netgroup">Lookup Netgroup</a>
+<li><code>setpgid</code>: <a href="#Process Group Functions">Process Group Functions</a>
+<li><code>setpgrp</code>: <a href="#Process Group Functions">Process Group Functions</a>
+<li><code>setpriority</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>setprotoent</code>: <a href="#Protocols Database">Protocols Database</a>
+<li><code>setpwent</code>: <a href="#Scanning All Users">Scanning All Users</a>
+<li><code>setregid</code>: <a href="#Setting Groups">Setting Groups</a>
+<li><code>setreuid</code>: <a href="#Setting User ID">Setting User ID</a>
+<li><code>setrlimit</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>setrlimit64</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>setservent</code>: <a href="#Services Database">Services Database</a>
+<li><code>setsid</code>: <a href="#Process Group Functions">Process Group Functions</a>
+<li><code>setsockopt</code>: <a href="#Socket Option Functions">Socket Option Functions</a>
+<li><code>setstate</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>setstate_r</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>settimeofday</code>: <a href="#High-Resolution Calendar">High-Resolution Calendar</a>
+<li><code>setuid</code>: <a href="#Setting User ID">Setting User ID</a>
+<li><code>setutent</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>setutxent</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>setvbuf</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>shutdown</code>: <a href="#Closing a Socket">Closing a Socket</a>
+<li><code>sigaction</code>: <a href="#Advanced Signal Handling">Advanced Signal Handling</a>
+<li><code>sigaddset</code>: <a href="#Signal Sets">Signal Sets</a>
+<li><code>sigaltstack</code>: <a href="#Signal Stack">Signal Stack</a>
+<li><code>sigblock</code>: <a href="#Blocking in BSD">Blocking in BSD</a>
+<li><code>sigdelset</code>: <a href="#Signal Sets">Signal Sets</a>
+<li><code>sigemptyset</code>: <a href="#Signal Sets">Signal Sets</a>
+<li><code>sigfillset</code>: <a href="#Signal Sets">Signal Sets</a>
+<li><code>siginterrupt</code>: <a href="#BSD Handler">BSD Handler</a>
+<li><code>sigismember</code>: <a href="#Signal Sets">Signal Sets</a>
+<li><code>siglongjmp</code>: <a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>
+<li><code>sigmask</code>: <a href="#Blocking in BSD">Blocking in BSD</a>
+<li><code>signal</code>: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><code>signbit</code>: <a href="#FP Bit Twiddling">FP Bit Twiddling</a>
+<li><code>significand</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>significandf</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>significandl</code>: <a href="#Normalization Functions">Normalization Functions</a>
+<li><code>sigpause</code>: <a href="#Blocking in BSD">Blocking in BSD</a>
+<li><code>sigpending</code>: <a href="#Checking for Pending Signals">Checking for Pending Signals</a>
+<li><code>sigprocmask</code>: <a href="#Process Signal Mask">Process Signal Mask</a>
+<li><code>sigsetjmp</code>: <a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>
+<li><code>sigsetmask</code>: <a href="#Blocking in BSD">Blocking in BSD</a>
+<li><code>sigstack</code>: <a href="#Signal Stack">Signal Stack</a>
 <li><code>sigsuspend</code>: <a href="#Sigsuspend">Sigsuspend</a>
-<li><code>sigvec</code>: <a href="#BSD%20Handler">BSD Handler</a>
-<li><code>sin</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>sincos</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>sincosf</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>sincosl</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>sinf</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>sinh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>sinhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>sinhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>sinl</code>: <a href="#Trig%20Functions">Trig Functions</a>
+<li><code>sigvec</code>: <a href="#BSD Handler">BSD Handler</a>
+<li><code>sin</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>sincos</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>sincosf</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>sincosl</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>sinf</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>sinh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>sinhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>sinhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>sinl</code>: <a href="#Trig Functions">Trig Functions</a>
 <li><code>sleep</code>: <a href="#Sleeping">Sleeping</a>
-<li><code>snprintf</code>: <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><code>socket</code>: <a href="#Creating%20a%20Socket">Creating a Socket</a>
-<li><code>socketpair</code>: <a href="#Socket%20Pairs">Socket Pairs</a>
-<li><code>sprintf</code>: <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><code>sqrt</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>sqrtf</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>sqrtl</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>srand</code>: <a href="#ISO%20Random">ISO Random</a>
-<li><code>srand48</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>srand48_r</code>: <a href="#SVID%20Random">SVID Random</a>
-<li><code>srandom</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>srandom_r</code>: <a href="#BSD%20Random">BSD Random</a>
-<li><code>sscanf</code>: <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>
-<li><code>ssignal</code>: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><code>stat</code>: <a href="#Reading%20Attributes">Reading Attributes</a>
-<li><code>stat64</code>: <a href="#Reading%20Attributes">Reading Attributes</a>
-<li><code>stime</code>: <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>
-<li><code>stpcpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>stpncpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strcasecmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>strcasestr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strcat</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strchr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strchrnul</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strcmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>strcoll</code>: <a href="#Collation%20Functions">Collation Functions</a>
-<li><code>strcpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strcspn</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strdup</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strdupa</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strerror</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>strerror_r</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>strfmon</code>: <a href="#Formatting%20Numbers">Formatting Numbers</a>
+<li><code>snprintf</code>: <a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><code>socket</code>: <a href="#Creating a Socket">Creating a Socket</a>
+<li><code>socketpair</code>: <a href="#Socket Pairs">Socket Pairs</a>
+<li><code>sprintf</code>: <a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><code>sqrt</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>sqrtf</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>sqrtl</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>srand</code>: <a href="#ISO Random">ISO Random</a>
+<li><code>srand48</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>srand48_r</code>: <a href="#SVID Random">SVID Random</a>
+<li><code>srandom</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>srandom_r</code>: <a href="#BSD Random">BSD Random</a>
+<li><code>sscanf</code>: <a href="#Formatted Input Functions">Formatted Input Functions</a>
+<li><code>ssignal</code>: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><code>stat</code>: <a href="#Reading Attributes">Reading Attributes</a>
+<li><code>stat64</code>: <a href="#Reading Attributes">Reading Attributes</a>
+<li><code>stime</code>: <a href="#Simple Calendar Time">Simple Calendar Time</a>
+<li><code>stpcpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>stpncpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strcasecmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>strcasestr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strcat</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strchr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strchrnul</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strcmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>strcoll</code>: <a href="#Collation Functions">Collation Functions</a>
+<li><code>strcpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strcspn</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strdup</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strdupa</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strerror</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>strerror_r</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>strfmon</code>: <a href="#Formatting Numbers">Formatting Numbers</a>
 <li><code>strfry</code>: <a href="#strfry">strfry</a>
-<li><code>strftime</code>: <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>
-<li><code>strlen</code>: <a href="#String%20Length">String Length</a>
-<li><code>strncasecmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>strncat</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strncmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>strncpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strndup</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strndupa</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>strnlen</code>: <a href="#String%20Length">String Length</a>
-<li><code>strpbrk</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strptime</code>: <a href="#Low-Level%20Time%20String%20Parsing">Low-Level Time String Parsing</a>
-<li><code>strrchr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strsep</code>: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li><code>strsignal</code>: <a href="#Signal%20Messages">Signal Messages</a>
-<li><code>strspn</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strstr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>strtod</code>: <a href="#Parsing%20of%20Floats">Parsing of Floats</a>
-<li><code>strtof</code>: <a href="#Parsing%20of%20Floats">Parsing of Floats</a>
-<li><code>strtoimax</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strtok</code>: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li><code>strtok_r</code>: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li><code>strtol</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strtold</code>: <a href="#Parsing%20of%20Floats">Parsing of Floats</a>
-<li><code>strtoll</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strtoq</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strtoul</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strtoull</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strtoumax</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strtouq</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>strverscmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>strxfrm</code>: <a href="#Collation%20Functions">Collation Functions</a>
-<li><code>stty</code>: <a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>
-<li><code>success</code>: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li><code>SUN_LEN</code>: <a href="#Local%20Namespace%20Details">Local Namespace Details</a>
-<li><code>swapcontext</code>: <a href="#System%20V%20contexts">System V contexts</a>
-<li><code>swprintf</code>: <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><code>swscanf</code>: <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>
-<li><code>symlink</code>: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li><code>sync</code>: <a href="#Synchronizing%20I%2fO">Synchronizing I/O</a>
-<li><code>syscall</code>: <a href="#System%20Calls">System Calls</a>
-<li><code>sysconf</code>: <a href="#Sysconf%20Definition">Sysconf Definition</a>
-<li><code>sysctl</code>: <a href="#System%20Parameters">System Parameters</a>
-<li><code>syslog</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>system</code>: <a href="#Running%20a%20Command">Running a Command</a>
-<li><code>sysv_signal</code>: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><code>tan</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>tanf</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>tanh</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>tanhf</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>tanhl</code>: <a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><code>tanl</code>: <a href="#Trig%20Functions">Trig Functions</a>
-<li><code>tcdrain</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>tcflow</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>tcflush</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>tcgetattr</code>: <a href="#Mode%20Functions">Mode Functions</a>
-<li><code>tcgetpgrp</code>: <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>
-<li><code>tcgetsid</code>: <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>
-<li><code>tcsendbreak</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>tcsetattr</code>: <a href="#Mode%20Functions">Mode Functions</a>
-<li><code>tcsetpgrp</code>: <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>
-<li><code>tdelete</code>: <a href="#Tree%20Search%20Function">Tree Search Function</a>
-<li><code>tdestroy</code>: <a href="#Tree%20Search%20Function">Tree Search Function</a>
-<li><code>telldir</code>: <a href="#Random%20Access%20Directory">Random Access Directory</a>
-<li><code>TEMP_FAILURE_RETRY</code>: <a href="#Interrupted%20Primitives">Interrupted Primitives</a>
-<li><code>tempnam</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>textdomain</code>: <a href="#Locating%20gettext%20catalog">Locating gettext catalog</a>
-<li><code>tfind</code>: <a href="#Tree%20Search%20Function">Tree Search Function</a>
-<li><code>tgamma</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>tgammaf</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>tgammal</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>time</code>: <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>
-<li><code>timegm</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li><code>timelocal</code>: <a href="#Broken-down%20Time">Broken-down Time</a>
-<li><code>times</code>: <a href="#Processor%20Time">Processor Time</a>
-<li><code>tmpfile</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>tmpfile64</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>tmpnam</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>tmpnam_r</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>toascii</code>: <a href="#Case%20Conversion">Case Conversion</a>
-<li><code>tolower</code>: <a href="#Case%20Conversion">Case Conversion</a>
-<li><code>toupper</code>: <a href="#Case%20Conversion">Case Conversion</a>
-<li><code>towctrans</code>: <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>
-<li><code>towlower</code>: <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>
-<li><code>towupper</code>: <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>
-<li><code>trunc</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>truncate</code>: <a href="#File%20Size">File Size</a>
-<li><code>truncate64</code>: <a href="#File%20Size">File Size</a>
-<li><code>truncf</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>truncl</code>: <a href="#Rounding%20Functions">Rounding Functions</a>
-<li><code>tryagain</code>: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li><code>tsearch</code>: <a href="#Tree%20Search%20Function">Tree Search Function</a>
-<li><code>ttyname</code>: <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>
-<li><code>ttyname_r</code>: <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>
-<li><code>twalk</code>: <a href="#Tree%20Search%20Function">Tree Search Function</a>
-<li><code>tzset</code>: <a href="#Time%20Zone%20Functions">Time Zone Functions</a>
-<li><code>ulimit</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>umask</code>: <a href="#Setting%20Permissions">Setting Permissions</a>
+<li><code>strftime</code>: <a href="#Formatting Calendar Time">Formatting Calendar Time</a>
+<li><code>strlen</code>: <a href="#String Length">String Length</a>
+<li><code>strncasecmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>strncat</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strncmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>strncpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strndup</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strndupa</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>strnlen</code>: <a href="#String Length">String Length</a>
+<li><code>strpbrk</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strptime</code>: <a href="#Low-Level Time String Parsing">Low-Level Time String Parsing</a>
+<li><code>strrchr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strsep</code>: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li><code>strsignal</code>: <a href="#Signal Messages">Signal Messages</a>
+<li><code>strspn</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strstr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>strtod</code>: <a href="#Parsing of Floats">Parsing of Floats</a>
+<li><code>strtof</code>: <a href="#Parsing of Floats">Parsing of Floats</a>
+<li><code>strtoimax</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strtok</code>: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li><code>strtok_r</code>: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li><code>strtol</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strtold</code>: <a href="#Parsing of Floats">Parsing of Floats</a>
+<li><code>strtoll</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strtoq</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strtoul</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strtoull</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strtoumax</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strtouq</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>strverscmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>strxfrm</code>: <a href="#Collation Functions">Collation Functions</a>
+<li><code>stty</code>: <a href="#BSD Terminal Modes">BSD Terminal Modes</a>
+<li><code>success</code>: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li><code>SUN_LEN</code>: <a href="#Local Namespace Details">Local Namespace Details</a>
+<li><code>swapcontext</code>: <a href="#System V contexts">System V contexts</a>
+<li><code>swprintf</code>: <a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><code>swscanf</code>: <a href="#Formatted Input Functions">Formatted Input Functions</a>
+<li><code>symlink</code>: <a href="#Symbolic Links">Symbolic Links</a>
+<li><code>sync</code>: <a href="#Synchronizing I%2fO">Synchronizing I/O</a>
+<li><code>syscall</code>: <a href="#System Calls">System Calls</a>
+<li><code>sysconf</code>: <a href="#Sysconf Definition">Sysconf Definition</a>
+<li><code>sysctl</code>: <a href="#System Parameters">System Parameters</a>
+<li><code>syslog</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>system</code>: <a href="#Running a Command">Running a Command</a>
+<li><code>sysv_signal</code>: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><code>tan</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>tanf</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>tanh</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>tanhf</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>tanhl</code>: <a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><code>tanl</code>: <a href="#Trig Functions">Trig Functions</a>
+<li><code>tcdrain</code>: <a href="#Line Control">Line Control</a>
+<li><code>tcflow</code>: <a href="#Line Control">Line Control</a>
+<li><code>tcflush</code>: <a href="#Line Control">Line Control</a>
+<li><code>tcgetattr</code>: <a href="#Mode Functions">Mode Functions</a>
+<li><code>tcgetpgrp</code>: <a href="#Terminal Access Functions">Terminal Access Functions</a>
+<li><code>tcgetsid</code>: <a href="#Terminal Access Functions">Terminal Access Functions</a>
+<li><code>tcsendbreak</code>: <a href="#Line Control">Line Control</a>
+<li><code>tcsetattr</code>: <a href="#Mode Functions">Mode Functions</a>
+<li><code>tcsetpgrp</code>: <a href="#Terminal Access Functions">Terminal Access Functions</a>
+<li><code>tdelete</code>: <a href="#Tree Search Function">Tree Search Function</a>
+<li><code>tdestroy</code>: <a href="#Tree Search Function">Tree Search Function</a>
+<li><code>telldir</code>: <a href="#Random Access Directory">Random Access Directory</a>
+<li><code>TEMP_FAILURE_RETRY</code>: <a href="#Interrupted Primitives">Interrupted Primitives</a>
+<li><code>tempnam</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>textdomain</code>: <a href="#Locating gettext catalog">Locating gettext catalog</a>
+<li><code>tfind</code>: <a href="#Tree Search Function">Tree Search Function</a>
+<li><code>tgamma</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>tgammaf</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>tgammal</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>time</code>: <a href="#Simple Calendar Time">Simple Calendar Time</a>
+<li><code>timegm</code>: <a href="#Broken-down Time">Broken-down Time</a>
+<li><code>timelocal</code>: <a href="#Broken-down Time">Broken-down Time</a>
+<li><code>times</code>: <a href="#Processor Time">Processor Time</a>
+<li><code>tmpfile</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>tmpfile64</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>tmpnam</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>tmpnam_r</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>toascii</code>: <a href="#Case Conversion">Case Conversion</a>
+<li><code>tolower</code>: <a href="#Case Conversion">Case Conversion</a>
+<li><code>toupper</code>: <a href="#Case Conversion">Case Conversion</a>
+<li><code>towctrans</code>: <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>
+<li><code>towlower</code>: <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>
+<li><code>towupper</code>: <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>
+<li><code>trunc</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>truncate</code>: <a href="#File Size">File Size</a>
+<li><code>truncate64</code>: <a href="#File Size">File Size</a>
+<li><code>truncf</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>truncl</code>: <a href="#Rounding Functions">Rounding Functions</a>
+<li><code>tryagain</code>: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li><code>tsearch</code>: <a href="#Tree Search Function">Tree Search Function</a>
+<li><code>ttyname</code>: <a href="#Is It a Terminal">Is It a Terminal</a>
+<li><code>ttyname_r</code>: <a href="#Is It a Terminal">Is It a Terminal</a>
+<li><code>twalk</code>: <a href="#Tree Search Function">Tree Search Function</a>
+<li><code>tzset</code>: <a href="#Time Zone Functions">Time Zone Functions</a>
+<li><code>ulimit</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>umask</code>: <a href="#Setting Permissions">Setting Permissions</a>
 <li><code>umount</code>: <a href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>
 <li><code>umount2</code>: <a href="#Mount-Unmount-Remount">Mount-Unmount-Remount</a>
-<li><code>uname</code>: <a href="#Platform%20Type">Platform Type</a>
-<li><code>unavail</code>: <a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li><code>ungetc</code>: <a href="#How%20Unread">How Unread</a>
-<li><code>ungetwc</code>: <a href="#How%20Unread">How Unread</a>
-<li><code>unlink</code>: <a href="#Deleting%20Files">Deleting Files</a>
+<li><code>uname</code>: <a href="#Platform Type">Platform Type</a>
+<li><code>unavail</code>: <a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li><code>ungetc</code>: <a href="#How Unread">How Unread</a>
+<li><code>ungetwc</code>: <a href="#How Unread">How Unread</a>
+<li><code>unlink</code>: <a href="#Deleting Files">Deleting Files</a>
 <li><code>unlockpt</code>: <a href="#Allocation">Allocation</a>
-<li><code>unsetenv</code>: <a href="#Environment%20Access">Environment Access</a>
-<li><code>updwtmp</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>utime</code>: <a href="#File%20Times">File Times</a>
-<li><code>utimes</code>: <a href="#File%20Times">File Times</a>
-<li><code>utmpname</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>utmpxname</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>va_alist</code>: <a href="#Old%20Varargs">Old Varargs</a>
-<li><code>va_arg</code>: <a href="#Argument%20Macros">Argument Macros</a>
-<li><code>va_dcl</code>: <a href="#Old%20Varargs">Old Varargs</a>
-<li><code>va_end</code>: <a href="#Argument%20Macros">Argument Macros</a>
-<li><code>va_start</code>: <a href="#Old%20Varargs">Old Varargs</a>, <a href="#Argument%20Macros">Argument Macros</a>
-<li><code>valloc</code>: <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>
-<li><code>vasprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>verr</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>verrx</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>versionsort</code>: <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>
-<li><code>versionsort64</code>: <a href="#Scanning%20Directory%20Content">Scanning Directory Content</a>
-<li><code>vfork</code>: <a href="#Creating%20a%20Process">Creating a Process</a>
-<li><code>vfprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>vfscanf</code>: <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>
-<li><code>vfwprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>vfwscanf</code>: <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>
-<li><code>vlimit</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>vprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>vscanf</code>: <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>
-<li><code>vsnprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>vsprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>vsscanf</code>: <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>
-<li><code>vswprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>vswscanf</code>: <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>
-<li><code>vsyslog</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>vtimes</code>: <a href="#Resource%20Usage">Resource Usage</a>
-<li><code>vwarn</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>vwarnx</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>vwprintf</code>: <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>
-<li><code>vwscanf</code>: <a href="#Variable%20Arguments%20Input">Variable Arguments Input</a>
-<li><code>wait</code>: <a href="#Process%20Completion">Process Completion</a>
-<li><code>wait3</code>: <a href="#BSD%20Wait%20Functions">BSD Wait Functions</a>
-<li><code>wait4</code>: <a href="#Process%20Completion">Process Completion</a>
-<li><code>waitpid</code>: <a href="#Process%20Completion">Process Completion</a>
-<li><code>warn</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>warnx</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>WCOREDUMP</code>: <a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><code>wcpcpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wcpncpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wcrtomb</code>: <a href="#Converting%20a%20Character">Converting a Character</a>
-<li><code>wcscasecmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>wcscat</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wcschr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcschrnul</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcscmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>wcscoll</code>: <a href="#Collation%20Functions">Collation Functions</a>
-<li><code>wcscpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wcscspn</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcsdup</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wcsftime</code>: <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>
-<li><code>wcslen</code>: <a href="#String%20Length">String Length</a>
-<li><code>wcsncasecmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>wcsncat</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wcsncmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>wcsncpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wcsnlen</code>: <a href="#String%20Length">String Length</a>
-<li><code>wcsnrtombs</code>: <a href="#Converting%20Strings">Converting Strings</a>
-<li><code>wcspbrk</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcsrchr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcsrtombs</code>: <a href="#Converting%20Strings">Converting Strings</a>
-<li><code>wcsspn</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcsstr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcstod</code>: <a href="#Parsing%20of%20Floats">Parsing of Floats</a>
-<li><code>wcstof</code>: <a href="#Parsing%20of%20Floats">Parsing of Floats</a>
-<li><code>wcstoimax</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcstok</code>: <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
-<li><code>wcstol</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcstold</code>: <a href="#Parsing%20of%20Floats">Parsing of Floats</a>
-<li><code>wcstoll</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcstombs</code>: <a href="#Non-reentrant%20String%20Conversion">Non-reentrant String Conversion</a>
-<li><code>wcstoq</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcstoul</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcstoull</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcstoumax</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcstouq</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><code>wcswcs</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wcsxfrm</code>: <a href="#Collation%20Functions">Collation Functions</a>
-<li><code>wctob</code>: <a href="#Converting%20a%20Character">Converting a Character</a>
-<li><code>wctomb</code>: <a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>
-<li><code>wctrans</code>: <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>
-<li><code>wctype</code>: <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>WEXITSTATUS</code>: <a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><code>WIFEXITED</code>: <a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><code>WIFSIGNALED</code>: <a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><code>WIFSTOPPED</code>: <a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><code>wmemchr</code>: <a href="#Search%20Functions">Search Functions</a>
-<li><code>wmemcmp</code>: <a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><code>wmemcpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wmemmove</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wmempcpy</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wmemset</code>: <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wordexp</code>: <a href="#Calling%20Wordexp">Calling Wordexp</a>
-<li><code>wordfree</code>: <a href="#Calling%20Wordexp">Calling Wordexp</a>
-<li><code>wprintf</code>: <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><code>write</code>: <a href="#I%2fO%20Primitives">I/O Primitives</a>
+<li><code>unsetenv</code>: <a href="#Environment Access">Environment Access</a>
+<li><code>updwtmp</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>utime</code>: <a href="#File Times">File Times</a>
+<li><code>utimes</code>: <a href="#File Times">File Times</a>
+<li><code>utmpname</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>utmpxname</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>va_alist</code>: <a href="#Old Varargs">Old Varargs</a>
+<li><code>va_arg</code>: <a href="#Argument Macros">Argument Macros</a>
+<li><code>va_dcl</code>: <a href="#Old Varargs">Old Varargs</a>
+<li><code>va_end</code>: <a href="#Argument Macros">Argument Macros</a>
+<li><code>va_start</code>: <a href="#Old Varargs">Old Varargs</a>, <a href="#Argument Macros">Argument Macros</a>
+<li><code>valloc</code>: <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>
+<li><code>vasprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>verr</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>verrx</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>versionsort</code>: <a href="#Scanning Directory Content">Scanning Directory Content</a>
+<li><code>versionsort64</code>: <a href="#Scanning Directory Content">Scanning Directory Content</a>
+<li><code>vfork</code>: <a href="#Creating a Process">Creating a Process</a>
+<li><code>vfprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>vfscanf</code>: <a href="#Variable Arguments Input">Variable Arguments Input</a>
+<li><code>vfwprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>vfwscanf</code>: <a href="#Variable Arguments Input">Variable Arguments Input</a>
+<li><code>vlimit</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>vprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>vscanf</code>: <a href="#Variable Arguments Input">Variable Arguments Input</a>
+<li><code>vsnprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>vsprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>vsscanf</code>: <a href="#Variable Arguments Input">Variable Arguments Input</a>
+<li><code>vswprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>vswscanf</code>: <a href="#Variable Arguments Input">Variable Arguments Input</a>
+<li><code>vsyslog</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>vtimes</code>: <a href="#Resource Usage">Resource Usage</a>
+<li><code>vwarn</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>vwarnx</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>vwprintf</code>: <a href="#Variable Arguments Output">Variable Arguments Output</a>
+<li><code>vwscanf</code>: <a href="#Variable Arguments Input">Variable Arguments Input</a>
+<li><code>wait</code>: <a href="#Process Completion">Process Completion</a>
+<li><code>wait3</code>: <a href="#BSD Wait Functions">BSD Wait Functions</a>
+<li><code>wait4</code>: <a href="#Process Completion">Process Completion</a>
+<li><code>waitpid</code>: <a href="#Process Completion">Process Completion</a>
+<li><code>warn</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>warnx</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>WCOREDUMP</code>: <a href="#Process Completion Status">Process Completion Status</a>
+<li><code>wcpcpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wcpncpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wcrtomb</code>: <a href="#Converting a Character">Converting a Character</a>
+<li><code>wcscasecmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>wcscat</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wcschr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcschrnul</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcscmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>wcscoll</code>: <a href="#Collation Functions">Collation Functions</a>
+<li><code>wcscpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wcscspn</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcsdup</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wcsftime</code>: <a href="#Formatting Calendar Time">Formatting Calendar Time</a>
+<li><code>wcslen</code>: <a href="#String Length">String Length</a>
+<li><code>wcsncasecmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>wcsncat</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wcsncmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>wcsncpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wcsnlen</code>: <a href="#String Length">String Length</a>
+<li><code>wcsnrtombs</code>: <a href="#Converting Strings">Converting Strings</a>
+<li><code>wcspbrk</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcsrchr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcsrtombs</code>: <a href="#Converting Strings">Converting Strings</a>
+<li><code>wcsspn</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcsstr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcstod</code>: <a href="#Parsing of Floats">Parsing of Floats</a>
+<li><code>wcstof</code>: <a href="#Parsing of Floats">Parsing of Floats</a>
+<li><code>wcstoimax</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcstok</code>: <a href="#Finding Tokens in a String">Finding Tokens in a String</a>
+<li><code>wcstol</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcstold</code>: <a href="#Parsing of Floats">Parsing of Floats</a>
+<li><code>wcstoll</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcstombs</code>: <a href="#Non-reentrant String Conversion">Non-reentrant String Conversion</a>
+<li><code>wcstoq</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcstoul</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcstoull</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcstoumax</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcstouq</code>: <a href="#Parsing of Integers">Parsing of Integers</a>
+<li><code>wcswcs</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wcsxfrm</code>: <a href="#Collation Functions">Collation Functions</a>
+<li><code>wctob</code>: <a href="#Converting a Character">Converting a Character</a>
+<li><code>wctomb</code>: <a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>
+<li><code>wctrans</code>: <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>
+<li><code>wctype</code>: <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>WEXITSTATUS</code>: <a href="#Process Completion Status">Process Completion Status</a>
+<li><code>WIFEXITED</code>: <a href="#Process Completion Status">Process Completion Status</a>
+<li><code>WIFSIGNALED</code>: <a href="#Process Completion Status">Process Completion Status</a>
+<li><code>WIFSTOPPED</code>: <a href="#Process Completion Status">Process Completion Status</a>
+<li><code>wmemchr</code>: <a href="#Search Functions">Search Functions</a>
+<li><code>wmemcmp</code>: <a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><code>wmemcpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wmemmove</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wmempcpy</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wmemset</code>: <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wordexp</code>: <a href="#Calling Wordexp">Calling Wordexp</a>
+<li><code>wordfree</code>: <a href="#Calling Wordexp">Calling Wordexp</a>
+<li><code>wprintf</code>: <a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><code>write</code>: <a href="#I%2fO Primitives">I/O Primitives</a>
 <li><code>writev</code>: <a href="#Scatter-Gather">Scatter-Gather</a>
-<li><code>wscanf</code>: <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>
-<li><code>WSTOPSIG</code>: <a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><code>WTERMSIG</code>: <a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><code>y0</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>y0f</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>y0l</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>y1</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>y1f</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>y1l</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>yn</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>ynf</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>ynl</code>: <a href="#Special%20Functions">Special Functions</a>
-</ul>
-<p><hr>
-Node:<a name="Variable%20Index">Variable Index</a>,
-Next:<a rel=next accesskey=n href="#File%20Index">File Index</a>,
-Previous:<a rel=previous accesskey=p href="#Function%20Index">Function Index</a>,
+<li><code>wscanf</code>: <a href="#Formatted Input Functions">Formatted Input Functions</a>
+<li><code>WSTOPSIG</code>: <a href="#Process Completion Status">Process Completion Status</a>
+<li><code>WTERMSIG</code>: <a href="#Process Completion Status">Process Completion Status</a>
+<li><code>y0</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>y0f</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>y0l</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>y1</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>y1f</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>y1l</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>yn</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>ynf</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>ynl</code>: <a href="#Special Functions">Special Functions</a>
+</ul>
+<p><hr>
+Node:<a name="Variable Index">Variable Index</a>,
+Next:<a rel=next accesskey=n href="#File Index">File Index</a>,
+Previous:<a rel=previous accesskey=p href="#Function Index">Function Index</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Variable and Constant Macro Index</h2>
 
 <ul compact>
-<li><code>(*__gconv_end_fct)</code>: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li><code>(*__gconv_fct)</code>: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li><code>(*__gconv_init_fct)</code>: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li><code>__free_hook</code>: <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>
-<li><code>__malloc_hook</code>: <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>
-<li><code>__malloc_initialize_hook</code>: <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>
-<li><code>__memalign_hook</code>: <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>
-<li><code>__realloc_hook</code>: <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>
-<li><code>_BSD_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_Complex_I</code>: <a href="#Complex%20Numbers">Complex Numbers</a>
-<li><code>_FILE_OFFSET_BITS</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_GNU_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_IOFBF</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>_IOLBF</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>_IONBF</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>_ISOC99_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_LARGEFILE64_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_LARGEFILE_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_PATH_FSTAB</code>: <a href="#Mount%20Information">Mount Information</a>
-<li><code>_PATH_MNTTAB</code>: <a href="#Mount%20Information">Mount Information</a>
-<li><code>_PATH_MOUNTED</code>: <a href="#Mount%20Information">Mount Information</a>
-<li><code>_PATH_UTMP</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>_PATH_WTMP</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>_POSIX2_C_DEV</code>: <a href="#System%20Options">System Options</a>
-<li><code>_POSIX2_C_VERSION</code>: <a href="#Version%20Supported">Version Supported</a>
-<li><code>_POSIX2_FORT_DEV</code>: <a href="#System%20Options">System Options</a>
-<li><code>_POSIX2_FORT_RUN</code>: <a href="#System%20Options">System Options</a>
-<li><code>_POSIX2_LOCALEDEF</code>: <a href="#System%20Options">System Options</a>
-<li><code>_POSIX2_SW_DEV</code>: <a href="#System%20Options">System Options</a>
-<li><code>_POSIX_C_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_POSIX_CHOWN_RESTRICTED</code>: <a href="#Options%20for%20Files">Options for Files</a>
-<li><code>_POSIX_JOB_CONTROL</code>: <a href="#System%20Options">System Options</a>
-<li><code>_POSIX_NO_TRUNC</code>: <a href="#Options%20for%20Files">Options for Files</a>
-<li><code>_POSIX_SAVED_IDS</code>: <a href="#System%20Options">System Options</a>
-<li><code>_POSIX_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_POSIX_VDISABLE</code>: <a href="#Options%20for%20Files">Options for Files</a>, <a href="#Special%20Characters">Special Characters</a>
-<li><code>_POSIX_VERSION</code>: <a href="#Version%20Supported">Version Supported</a>
-<li><code>_REENTRANT</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_SC_2_C_DEV</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_2_FORT_DEV</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_2_FORT_RUN</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_2_LOCALEDEF</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_2_SW_DEV</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_2_VERSION</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_AIO_LISTIO_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_AIO_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_AIO_PRIO_DELTA_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_ARG_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_ASYNCHRONOUS_IO</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_ATEXIT_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_AVPHYS_PAGES</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>, <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>
-<li><code>_SC_BC_BASE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_BC_DIM_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_BC_SCALE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_BC_STRING_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_CHAR_BIT</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_CHAR_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_CHAR_MIN</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_CHARCLASS_NAME_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_CHILD_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_CLK_TCK</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_COLL_WEIGHTS_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_DELAYTIMER_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_EQUIV_CLASS_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_EXPR_NEST_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_FSYNC</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_GETGR_R_SIZE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_GETPW_R_SIZE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_INT_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_INT_MIN</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_JOB_CONTROL</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_LINE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_LOGIN_NAME_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_LONG_BIT</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MAPPED_FILES</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MB_LEN_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MEMLOCK</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MEMLOCK_RANGE</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MEMORY_PROTECTION</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MESSAGE_PASSING</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MQ_OPEN_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_MQ_PRIO_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NGROUPS_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NL_ARGMAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NL_LANGMAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NL_MSGMAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NL_NMAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NL_SETMAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NL_TEXTMAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_NPROCESSORS_CONF</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>, <a href="#Processor%20Resources">Processor Resources</a>
-<li><code>_SC_NPROCESSORS_ONLN</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>, <a href="#Processor%20Resources">Processor Resources</a>
-<li><code>_SC_NZERO</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_OPEN_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PAGESIZE</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>, <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>, <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>_SC_PHYS_PAGES</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>, <a href="#Query%20Memory%20Parameters">Query Memory Parameters</a>
-<li><code>_SC_PII</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_INTERNET</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_INTERNET_DGRAM</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_INTERNET_STREAM</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_OSI</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_OSI_CLTS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_OSI_COTS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_OSI_M</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_SOCKET</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PII_XTI</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PRIORITIZED_IO</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_PRIORITY_SCHEDULING</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_REALTIME_SIGNALS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_RTSIG_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SAVED_IDS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SCHAR_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SCHAR_MIN</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SELECT</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SEM_NSEMS_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SEM_VALUE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SEMAPHORES</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SHARED_MEMORY_OBJECTS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SHRT_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SHRT_MIN</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SIGQUEUE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_STREAM_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_SYNCHRONIZED_IO</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_T_IOV_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_ATTR_STACKADDR</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_ATTR_STACKSIZE</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_DESTRUCTOR_ITERATIONS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_KEYS_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_PRIO_INHERIT</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_PRIO_PROTECT</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_PRIORITY_SCHEDULING</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_PROCESS_SHARED</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_SAFE_FUNCTIONS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_STACK_MIN</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREAD_THREADS_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_THREADS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_TIMER_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_TIMERS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_TTY_NAME_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_TZNAME_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_UCHAR_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_UINT_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_UIO_MAXIOV</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_ULONG_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_USHRT_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_VERSION</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_WORD_BIT</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_CRYPT</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_ENH_I18N</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_LEGACY</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_REALTIME</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_REALTIME_THREADS</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_SHM</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_UNIX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_VERSION</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_XCU_VERSION</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_XPG2</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_XPG3</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SC_XOPEN_XPG4</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>_SVID_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_THREAD_SAFE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_XOPEN_SOURCE</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>_XOPEN_SOURCE_EXTENDED</code>: <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>ABDAY_1</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABDAY_2</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABDAY_3</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABDAY_4</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABDAY_5</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABDAY_6</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABDAY_7</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_1</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_10</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_11</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_12</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_2</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_3</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_4</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_5</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_6</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_7</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_8</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ABMON_9</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ACCOUNTING</code>: <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>AF_FILE</code>: <a href="#Address%20Formats">Address Formats</a>
-<li><code>AF_INET</code>: <a href="#Address%20Formats">Address Formats</a>
-<li><code>AF_LOCAL</code>: <a href="#Address%20Formats">Address Formats</a>
-<li><code>AF_UNIX</code>: <a href="#Address%20Formats">Address Formats</a>
-<li><code>AF_UNSPEC</code>: <a href="#Address%20Formats">Address Formats</a>
-<li><code>aliases</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>ALT_DIGITS</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ALTWERASE</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>AM_STR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ARG_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>argp_err_exit_status</code>: <a href="#Argp%20Global%20Variables">Argp Global Variables</a>
-<li><code>ARGP_ERR_UNKNOWN</code>: <a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>
-<li><code>ARGP_HELP_BUG_ADDR</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_DOC</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_EXIT_ERR</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_EXIT_OK</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_LONG</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_LONG_ONLY</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_POST_DOC</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_PRE_DOC</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_SEE</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_SHORT_USAGE</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_STD_ERR</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_STD_HELP</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_STD_USAGE</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_HELP_USAGE</code>: <a href="#Argp%20Help%20Flags">Argp Help Flags</a>
-<li><code>ARGP_IN_ORDER</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>ARGP_KEY_ARG</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_KEY_ARGS</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_KEY_END</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_KEY_ERROR</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_KEY_FINI</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_KEY_HELP_ARGS_DOC</code>: <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>
-<li><code>ARGP_KEY_HELP_DUP_ARGS_NOTE</code>: <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>
-<li><code>ARGP_KEY_HELP_EXTRA</code>: <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>
-<li><code>ARGP_KEY_HELP_HEADER</code>: <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>
-<li><code>ARGP_KEY_HELP_POST_DOC</code>: <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>
-<li><code>ARGP_KEY_HELP_PRE_DOC</code>: <a href="#Argp%20Help%20Filter%20Keys">Argp Help Filter Keys</a>
-<li><code>ARGP_KEY_INIT</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_KEY_NO_ARGS</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_KEY_SUCCESS</code>: <a href="#Argp%20Special%20Keys">Argp Special Keys</a>
-<li><code>ARGP_LONG_ONLY</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>ARGP_NO_ARGS</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>ARGP_NO_ERRS</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>ARGP_NO_EXIT</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>ARGP_NO_HELP</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>ARGP_PARSE_ARGV0</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>argp_program_bug_address</code>: <a href="#Argp%20Global%20Variables">Argp Global Variables</a>
-<li><code>argp_program_version</code>: <a href="#Argp%20Global%20Variables">Argp Global Variables</a>
-<li><code>argp_program_version_hook</code>: <a href="#Argp%20Global%20Variables">Argp Global Variables</a>
-<li><code>ARGP_SILENT</code>: <a href="#Argp%20Flags">Argp Flags</a>
-<li><code>B0</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B110</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B115200</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B1200</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B134</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B150</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B1800</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B19200</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B200</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B230400</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B2400</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B300</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B38400</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B460800</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B4800</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B50</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B57600</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B600</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B75</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>B9600</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>BC_BASE_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>BC_DIM_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>BC_SCALE_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>BC_STRING_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>BOOT_TIME</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>BRKINT</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>BUFSIZ</code>: <a href="#Controlling%20Buffering">Controlling Buffering</a>
-<li><code>CCTS_OFLOW</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CHAR_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>CHAR_MIN</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>CHILD_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>CIGNORE</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CLK_TCK</code>: <a href="#CPU%20Time">CPU Time</a>
-<li><code>CLOCAL</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CLOCKS_PER_SEC</code>: <a href="#CPU%20Time">CPU Time</a>
-<li><code>CODESET</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>COLL_WEIGHTS_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>COREFILE</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>CREAD</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CRNCYSTR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>CRTS_IFLOW</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CS5</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CS6</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CS7</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CS8</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CSIZE</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CSTOPB</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>CURRENCY_SYMBOL</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>D_FMT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>D_T_FMT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DAY_1</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DAY_2</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DAY_3</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DAY_4</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DAY_5</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DAY_6</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DAY_7</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>daylight</code>: <a href="#Time%20Zone%20Functions">Time Zone Functions</a>
-<li><code>DBL_DIG</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_EPSILON</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_MANT_DIG</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_MAX</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_MAX_10_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_MAX_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_MIN</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_MIN_10_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DBL_MIN_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>DEAD_PROCESS</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>DECIMAL_POINT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>DES_DECRYPT</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DES_ENCRYPT</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DES_HW</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DES_SW</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DESERR_BADPARAM</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DESERR_HWERROR</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DESERR_NOHWDEVICE</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DESERR_NONE</code>: <a href="#DES%20Encryption">DES Encryption</a>
-<li><code>DT_BLK</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>DT_CHR</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>DT_DIR</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>DT_FIFO</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>DT_REG</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>DT_SOCK</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>DT_UNKNOWN</code>: <a href="#Directory%20Entries">Directory Entries</a>
-<li><code>E2BIG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EACCES</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EADDRINUSE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EADDRNOTAVAIL</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EADV</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EAFNOSUPPORT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EAGAIN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EALREADY</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EAUTH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBACKGROUND</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADF</code>: <a href="#Line%20Control">Line Control</a>, <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADFD</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADMSG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADR</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADRPC</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADRQC</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBADSLT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBFONT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EBUSY</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ECHILD</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ECHO</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ECHOCTL</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ECHOE</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ECHOK</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ECHOKE</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ECHONL</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ECHOPRT</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ECHRNG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ECOMM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ECONNABORTED</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ECONNREFUSED</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ECONNRESET</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ED</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EDEADLK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EDEADLOCK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EDESTADDRREQ</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EDIED</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EDOM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EDOTDOT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EDQUOT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EEXIST</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EFAULT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EFBIG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EFTYPE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EGRATUITOUS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EGREGIOUS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EHOSTDOWN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EHOSTUNREACH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EIDRM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EIEIO</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EILSEQ</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EINPROGRESS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EINTR</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EINVAL</code>: <a href="#Line%20Control">Line Control</a>, <a href="#Error%20Codes">Error Codes</a>
-<li><code>EIO</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EISCONN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EISDIR</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EISNAM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EL2HLT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EL2NSYNC</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EL3HLT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EL3RST</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ELIBACC</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ELIBBAD</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ELIBEXEC</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ELIBMAX</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ELIBSCN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ELNRNG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ELOOP</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EMEDIUMTYPE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EMFILE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EMLINK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EMPTY</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>EMSGSIZE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EMULTIHOP</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENAMETOOLONG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENAVAIL</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENEEDAUTH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENETDOWN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENETRESET</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENETUNREACH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENFILE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOANO</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOBUFS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOCSI</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENODATA</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENODEV</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOENT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOEXEC</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOLCK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOLINK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOMEDIUM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOMEM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOMSG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENONET</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOPKG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOPROTOOPT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOSPC</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOSR</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOSTR</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOSYS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTBLK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTCONN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTDIR</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTEMPTY</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTNAM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTSOCK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTSUP</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTTY</code>: <a href="#Line%20Control">Line Control</a>, <a href="#Error%20Codes">Error Codes</a>
-<li><code>ENOTUNIQ</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>environ</code>: <a href="#Environment%20Access">Environment Access</a>
-<li><code>ENXIO</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EOF</code>: <a href="#EOF%20and%20Errors">EOF and Errors</a>
-<li><code>EOPNOTSUPP</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EOVERFLOW</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPERM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPFNOSUPPORT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPIPE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPROCLIM</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPROCUNAVAIL</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPROGMISMATCH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPROGUNAVAIL</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPROTO</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPROTONOSUPPORT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EPROTOTYPE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EQUIV_CLASS_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>ERA</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ERA_D_FMT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ERA_D_T_FMT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ERA_T_FMT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ERA_YEAR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>ERANGE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EREMCHG</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EREMOTE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EREMOTEIO</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ERESTART</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EROFS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ERPCMISMATCH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>errno</code>: <a href="#Checking%20for%20Errors">Checking for Errors</a>
-<li><code>error_message_count</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>error_one_per_line</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>error_print_progname</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>ESHUTDOWN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ESOCKTNOSUPPORT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ESPIPE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ESRCH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ESRMNT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ESTALE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ESTRPIPE</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ethers</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>ETIME</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ETIMEDOUT</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ETOOMANYREFS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>ETXTBSY</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EUCLEAN</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EUNATCH</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EUSERS</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EWOULDBLOCK</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EXDEV</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EXFULL</code>: <a href="#Error%20Codes">Error Codes</a>
-<li><code>EXIT_FAILURE</code>: <a href="#Exit%20Status">Exit Status</a>
-<li><code>EXIT_SUCCESS</code>: <a href="#Exit%20Status">Exit Status</a>
-<li><code>EXPR_NEST_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>EXTA</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>EXTB</code>: <a href="#Line%20Speed">Line Speed</a>
-<li><code>F_DUPFD</code>: <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>
-<li><code>F_GETFD</code>: <a href="#Descriptor%20Flags">Descriptor Flags</a>
-<li><code>F_GETFL</code>: <a href="#Getting%20File%20Status%20Flags">Getting File Status Flags</a>
-<li><code>F_GETLK</code>: <a href="#File%20Locks">File Locks</a>
-<li><code>F_GETOWN</code>: <a href="#Interrupt%20Input">Interrupt Input</a>
-<li><code>F_OK</code>: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li><code>F_RDLCK</code>: <a href="#File%20Locks">File Locks</a>
-<li><code>F_SETFD</code>: <a href="#Descriptor%20Flags">Descriptor Flags</a>
-<li><code>F_SETFL</code>: <a href="#Getting%20File%20Status%20Flags">Getting File Status Flags</a>
-<li><code>F_SETLK</code>: <a href="#File%20Locks">File Locks</a>
-<li><code>F_SETLKW</code>: <a href="#File%20Locks">File Locks</a>
-<li><code>F_SETOWN</code>: <a href="#Interrupt%20Input">Interrupt Input</a>
-<li><code>F_UNLCK</code>: <a href="#File%20Locks">File Locks</a>
-<li><code>F_WRLCK</code>: <a href="#File%20Locks">File Locks</a>
-<li><code>FD_CLOEXEC</code>: <a href="#Descriptor%20Flags">Descriptor Flags</a>
-<li><code>FD_SETSIZE</code>: <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li><code>FE_DFL_ENV</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>FE_DIVBYZERO</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
+<li><code>(*__gconv_end_fct)</code>: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li><code>(*__gconv_fct)</code>: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li><code>(*__gconv_init_fct)</code>: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li><code>__free_hook</code>: <a href="#Hooks for Malloc">Hooks for Malloc</a>
+<li><code>__malloc_hook</code>: <a href="#Hooks for Malloc">Hooks for Malloc</a>
+<li><code>__malloc_initialize_hook</code>: <a href="#Hooks for Malloc">Hooks for Malloc</a>
+<li><code>__memalign_hook</code>: <a href="#Hooks for Malloc">Hooks for Malloc</a>
+<li><code>__realloc_hook</code>: <a href="#Hooks for Malloc">Hooks for Malloc</a>
+<li><code>_BSD_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_Complex_I</code>: <a href="#Complex Numbers">Complex Numbers</a>
+<li><code>_FILE_OFFSET_BITS</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_GNU_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_IOFBF</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>_IOLBF</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>_IONBF</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>_ISOC99_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_LARGEFILE64_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_LARGEFILE_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_PATH_FSTAB</code>: <a href="#Mount Information">Mount Information</a>
+<li><code>_PATH_MNTTAB</code>: <a href="#Mount Information">Mount Information</a>
+<li><code>_PATH_MOUNTED</code>: <a href="#Mount Information">Mount Information</a>
+<li><code>_PATH_UTMP</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>_PATH_WTMP</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>_POSIX2_C_DEV</code>: <a href="#System Options">System Options</a>
+<li><code>_POSIX2_C_VERSION</code>: <a href="#Version Supported">Version Supported</a>
+<li><code>_POSIX2_FORT_DEV</code>: <a href="#System Options">System Options</a>
+<li><code>_POSIX2_FORT_RUN</code>: <a href="#System Options">System Options</a>
+<li><code>_POSIX2_LOCALEDEF</code>: <a href="#System Options">System Options</a>
+<li><code>_POSIX2_SW_DEV</code>: <a href="#System Options">System Options</a>
+<li><code>_POSIX_C_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_POSIX_CHOWN_RESTRICTED</code>: <a href="#Options for Files">Options for Files</a>
+<li><code>_POSIX_JOB_CONTROL</code>: <a href="#System Options">System Options</a>
+<li><code>_POSIX_NO_TRUNC</code>: <a href="#Options for Files">Options for Files</a>
+<li><code>_POSIX_SAVED_IDS</code>: <a href="#System Options">System Options</a>
+<li><code>_POSIX_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_POSIX_VDISABLE</code>: <a href="#Options for Files">Options for Files</a>, <a href="#Special Characters">Special Characters</a>
+<li><code>_POSIX_VERSION</code>: <a href="#Version Supported">Version Supported</a>
+<li><code>_REENTRANT</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_SC_2_C_DEV</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_2_FORT_DEV</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_2_FORT_RUN</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_2_LOCALEDEF</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_2_SW_DEV</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_2_VERSION</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_AIO_LISTIO_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_AIO_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_AIO_PRIO_DELTA_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_ARG_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_ASYNCHRONOUS_IO</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_ATEXIT_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_AVPHYS_PAGES</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>, <a href="#Query Memory Parameters">Query Memory Parameters</a>
+<li><code>_SC_BC_BASE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_BC_DIM_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_BC_SCALE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_BC_STRING_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_CHAR_BIT</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_CHAR_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_CHAR_MIN</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_CHARCLASS_NAME_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_CHILD_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_CLK_TCK</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_COLL_WEIGHTS_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_DELAYTIMER_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_EQUIV_CLASS_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_EXPR_NEST_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_FSYNC</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_GETGR_R_SIZE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_GETPW_R_SIZE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_INT_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_INT_MIN</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_JOB_CONTROL</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_LINE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_LOGIN_NAME_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_LONG_BIT</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MAPPED_FILES</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MB_LEN_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MEMLOCK</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MEMLOCK_RANGE</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MEMORY_PROTECTION</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MESSAGE_PASSING</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MQ_OPEN_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_MQ_PRIO_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NGROUPS_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NL_ARGMAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NL_LANGMAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NL_MSGMAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NL_NMAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NL_SETMAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NL_TEXTMAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_NPROCESSORS_CONF</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>, <a href="#Processor Resources">Processor Resources</a>
+<li><code>_SC_NPROCESSORS_ONLN</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>, <a href="#Processor Resources">Processor Resources</a>
+<li><code>_SC_NZERO</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_OPEN_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PAGESIZE</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>, <a href="#Query Memory Parameters">Query Memory Parameters</a>, <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>_SC_PHYS_PAGES</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>, <a href="#Query Memory Parameters">Query Memory Parameters</a>
+<li><code>_SC_PII</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_INTERNET</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_INTERNET_DGRAM</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_INTERNET_STREAM</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_OSI</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_OSI_CLTS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_OSI_COTS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_OSI_M</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_SOCKET</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PII_XTI</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PRIORITIZED_IO</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_PRIORITY_SCHEDULING</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_REALTIME_SIGNALS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_RTSIG_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SAVED_IDS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SCHAR_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SCHAR_MIN</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SELECT</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SEM_NSEMS_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SEM_VALUE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SEMAPHORES</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SHARED_MEMORY_OBJECTS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SHRT_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SHRT_MIN</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SIGQUEUE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_STREAM_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_SYNCHRONIZED_IO</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_T_IOV_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_ATTR_STACKADDR</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_ATTR_STACKSIZE</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_DESTRUCTOR_ITERATIONS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_KEYS_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_PRIO_INHERIT</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_PRIO_PROTECT</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_PRIORITY_SCHEDULING</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_PROCESS_SHARED</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_SAFE_FUNCTIONS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_STACK_MIN</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREAD_THREADS_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_THREADS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_TIMER_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_TIMERS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_TTY_NAME_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_TZNAME_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_UCHAR_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_UINT_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_UIO_MAXIOV</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_ULONG_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_USHRT_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_VERSION</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_WORD_BIT</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_CRYPT</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_ENH_I18N</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_LEGACY</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_REALTIME</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_REALTIME_THREADS</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_SHM</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_UNIX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_VERSION</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_XCU_VERSION</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_XPG2</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_XPG3</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SC_XOPEN_XPG4</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>_SVID_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_THREAD_SAFE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_XOPEN_SOURCE</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>_XOPEN_SOURCE_EXTENDED</code>: <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>ABDAY_1</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABDAY_2</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABDAY_3</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABDAY_4</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABDAY_5</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABDAY_6</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABDAY_7</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_1</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_10</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_11</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_12</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_2</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_3</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_4</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_5</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_6</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_7</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_8</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ABMON_9</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ACCOUNTING</code>: <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>AF_FILE</code>: <a href="#Address Formats">Address Formats</a>
+<li><code>AF_INET</code>: <a href="#Address Formats">Address Formats</a>
+<li><code>AF_LOCAL</code>: <a href="#Address Formats">Address Formats</a>
+<li><code>AF_UNIX</code>: <a href="#Address Formats">Address Formats</a>
+<li><code>AF_UNSPEC</code>: <a href="#Address Formats">Address Formats</a>
+<li><code>aliases</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>ALT_DIGITS</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ALTWERASE</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>AM_STR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ARG_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>argp_err_exit_status</code>: <a href="#Argp Global Variables">Argp Global Variables</a>
+<li><code>ARGP_ERR_UNKNOWN</code>: <a href="#Argp Parser Functions">Argp Parser Functions</a>
+<li><code>ARGP_HELP_BUG_ADDR</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_DOC</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_EXIT_ERR</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_EXIT_OK</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_LONG</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_LONG_ONLY</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_POST_DOC</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_PRE_DOC</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_SEE</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_SHORT_USAGE</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_STD_ERR</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_STD_HELP</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_STD_USAGE</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_HELP_USAGE</code>: <a href="#Argp Help Flags">Argp Help Flags</a>
+<li><code>ARGP_IN_ORDER</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>ARGP_KEY_ARG</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_KEY_ARGS</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_KEY_END</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_KEY_ERROR</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_KEY_FINI</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_KEY_HELP_ARGS_DOC</code>: <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>
+<li><code>ARGP_KEY_HELP_DUP_ARGS_NOTE</code>: <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>
+<li><code>ARGP_KEY_HELP_EXTRA</code>: <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>
+<li><code>ARGP_KEY_HELP_HEADER</code>: <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>
+<li><code>ARGP_KEY_HELP_POST_DOC</code>: <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>
+<li><code>ARGP_KEY_HELP_PRE_DOC</code>: <a href="#Argp Help Filter Keys">Argp Help Filter Keys</a>
+<li><code>ARGP_KEY_INIT</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_KEY_NO_ARGS</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_KEY_SUCCESS</code>: <a href="#Argp Special Keys">Argp Special Keys</a>
+<li><code>ARGP_LONG_ONLY</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>ARGP_NO_ARGS</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>ARGP_NO_ERRS</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>ARGP_NO_EXIT</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>ARGP_NO_HELP</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>ARGP_PARSE_ARGV0</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>argp_program_bug_address</code>: <a href="#Argp Global Variables">Argp Global Variables</a>
+<li><code>argp_program_version</code>: <a href="#Argp Global Variables">Argp Global Variables</a>
+<li><code>argp_program_version_hook</code>: <a href="#Argp Global Variables">Argp Global Variables</a>
+<li><code>ARGP_SILENT</code>: <a href="#Argp Flags">Argp Flags</a>
+<li><code>B0</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B110</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B115200</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B1200</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B134</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B150</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B1800</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B19200</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B200</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B230400</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B2400</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B300</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B38400</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B460800</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B4800</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B50</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B57600</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B600</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B75</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>B9600</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>BC_BASE_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>BC_DIM_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>BC_SCALE_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>BC_STRING_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>BOOT_TIME</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>BRKINT</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>BUFSIZ</code>: <a href="#Controlling Buffering">Controlling Buffering</a>
+<li><code>CCTS_OFLOW</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CHAR_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>CHAR_MIN</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>CHILD_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>CIGNORE</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CLK_TCK</code>: <a href="#CPU Time">CPU Time</a>
+<li><code>CLOCAL</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CLOCKS_PER_SEC</code>: <a href="#CPU Time">CPU Time</a>
+<li><code>CODESET</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>COLL_WEIGHTS_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>COREFILE</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>CREAD</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CRNCYSTR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>CRTS_IFLOW</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CS5</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CS6</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CS7</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CS8</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CSIZE</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CSTOPB</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>CURRENCY_SYMBOL</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>D_FMT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>D_T_FMT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DAY_1</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DAY_2</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DAY_3</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DAY_4</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DAY_5</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DAY_6</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DAY_7</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>daylight</code>: <a href="#Time Zone Functions">Time Zone Functions</a>
+<li><code>DBL_DIG</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_EPSILON</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_MANT_DIG</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_MAX</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_MAX_10_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_MAX_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_MIN</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_MIN_10_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DBL_MIN_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>DEAD_PROCESS</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>DECIMAL_POINT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>DES_DECRYPT</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DES_ENCRYPT</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DES_HW</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DES_SW</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DESERR_BADPARAM</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DESERR_HWERROR</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DESERR_NOHWDEVICE</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DESERR_NONE</code>: <a href="#DES Encryption">DES Encryption</a>
+<li><code>DT_BLK</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>DT_CHR</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>DT_DIR</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>DT_FIFO</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>DT_REG</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>DT_SOCK</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>DT_UNKNOWN</code>: <a href="#Directory Entries">Directory Entries</a>
+<li><code>E2BIG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EACCES</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EADDRINUSE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EADDRNOTAVAIL</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EADV</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EAFNOSUPPORT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EAGAIN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EALREADY</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EAUTH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBACKGROUND</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBADE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBADF</code>: <a href="#Line Control">Line Control</a>, <a href="#Error Codes">Error Codes</a>
+<li><code>EBADFD</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBADMSG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBADR</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBADRPC</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBADRQC</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBADSLT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBFONT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EBUSY</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ECHILD</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ECHO</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ECHOCTL</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ECHOE</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ECHOK</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ECHOKE</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ECHONL</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ECHOPRT</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ECHRNG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ECOMM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ECONNABORTED</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ECONNREFUSED</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ECONNRESET</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ED</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EDEADLK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EDEADLOCK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EDESTADDRREQ</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EDIED</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EDOM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EDOTDOT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EDQUOT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EEXIST</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EFAULT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EFBIG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EFTYPE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EGRATUITOUS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EGREGIOUS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EHOSTDOWN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EHOSTUNREACH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EIDRM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EIEIO</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EILSEQ</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EINPROGRESS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EINTR</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EINVAL</code>: <a href="#Line Control">Line Control</a>, <a href="#Error Codes">Error Codes</a>
+<li><code>EIO</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EISCONN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EISDIR</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EISNAM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EL2HLT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EL2NSYNC</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EL3HLT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EL3RST</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ELIBACC</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ELIBBAD</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ELIBEXEC</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ELIBMAX</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ELIBSCN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ELNRNG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ELOOP</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EMEDIUMTYPE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EMFILE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EMLINK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EMPTY</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>EMSGSIZE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EMULTIHOP</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENAMETOOLONG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENAVAIL</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENEEDAUTH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENETDOWN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENETRESET</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENETUNREACH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENFILE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOANO</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOBUFS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOCSI</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENODATA</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENODEV</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOENT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOEXEC</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOLCK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOLINK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOMEDIUM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOMEM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOMSG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENONET</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOPKG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOPROTOOPT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOSPC</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOSR</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOSTR</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOSYS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTBLK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTCONN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTDIR</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTEMPTY</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTNAM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTSOCK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTSUP</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTTY</code>: <a href="#Line Control">Line Control</a>, <a href="#Error Codes">Error Codes</a>
+<li><code>ENOTUNIQ</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>environ</code>: <a href="#Environment Access">Environment Access</a>
+<li><code>ENXIO</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EOF</code>: <a href="#EOF and Errors">EOF and Errors</a>
+<li><code>EOPNOTSUPP</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EOVERFLOW</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPERM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPFNOSUPPORT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPIPE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPROCLIM</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPROCUNAVAIL</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPROGMISMATCH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPROGUNAVAIL</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPROTO</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPROTONOSUPPORT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EPROTOTYPE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EQUIV_CLASS_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>ERA</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ERA_D_FMT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ERA_D_T_FMT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ERA_T_FMT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ERA_YEAR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>ERANGE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EREMCHG</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EREMOTE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EREMOTEIO</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ERESTART</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EROFS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ERPCMISMATCH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>errno</code>: <a href="#Checking for Errors">Checking for Errors</a>
+<li><code>error_message_count</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>error_one_per_line</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>error_print_progname</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>ESHUTDOWN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ESOCKTNOSUPPORT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ESPIPE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ESRCH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ESRMNT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ESTALE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ESTRPIPE</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ethers</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>ETIME</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ETIMEDOUT</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ETOOMANYREFS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>ETXTBSY</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EUCLEAN</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EUNATCH</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EUSERS</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EWOULDBLOCK</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EXDEV</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EXFULL</code>: <a href="#Error Codes">Error Codes</a>
+<li><code>EXIT_FAILURE</code>: <a href="#Exit Status">Exit Status</a>
+<li><code>EXIT_SUCCESS</code>: <a href="#Exit Status">Exit Status</a>
+<li><code>EXPR_NEST_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>EXTA</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>EXTB</code>: <a href="#Line Speed">Line Speed</a>
+<li><code>F_DUPFD</code>: <a href="#Duplicating Descriptors">Duplicating Descriptors</a>
+<li><code>F_GETFD</code>: <a href="#Descriptor Flags">Descriptor Flags</a>
+<li><code>F_GETFL</code>: <a href="#Getting File Status Flags">Getting File Status Flags</a>
+<li><code>F_GETLK</code>: <a href="#File Locks">File Locks</a>
+<li><code>F_GETOWN</code>: <a href="#Interrupt Input">Interrupt Input</a>
+<li><code>F_OK</code>: <a href="#Testing File Access">Testing File Access</a>
+<li><code>F_RDLCK</code>: <a href="#File Locks">File Locks</a>
+<li><code>F_SETFD</code>: <a href="#Descriptor Flags">Descriptor Flags</a>
+<li><code>F_SETFL</code>: <a href="#Getting File Status Flags">Getting File Status Flags</a>
+<li><code>F_SETLK</code>: <a href="#File Locks">File Locks</a>
+<li><code>F_SETLKW</code>: <a href="#File Locks">File Locks</a>
+<li><code>F_SETOWN</code>: <a href="#Interrupt Input">Interrupt Input</a>
+<li><code>F_UNLCK</code>: <a href="#File Locks">File Locks</a>
+<li><code>F_WRLCK</code>: <a href="#File Locks">File Locks</a>
+<li><code>FD_CLOEXEC</code>: <a href="#Descriptor Flags">Descriptor Flags</a>
+<li><code>FD_SETSIZE</code>: <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li><code>FE_DFL_ENV</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>FE_DIVBYZERO</code>: <a href="#Status bit operations">Status bit operations</a>
 <li><code>FE_DOWNWARD</code>: <a href="#Rounding">Rounding</a>
-<li><code>FE_INEXACT</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
-<li><code>FE_INVALID</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
-<li><code>FE_NOMASK_ENV</code>: <a href="#Control%20Functions">Control Functions</a>
-<li><code>FE_OVERFLOW</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
+<li><code>FE_INEXACT</code>: <a href="#Status bit operations">Status bit operations</a>
+<li><code>FE_INVALID</code>: <a href="#Status bit operations">Status bit operations</a>
+<li><code>FE_NOMASK_ENV</code>: <a href="#Control Functions">Control Functions</a>
+<li><code>FE_OVERFLOW</code>: <a href="#Status bit operations">Status bit operations</a>
 <li><code>FE_TONEAREST</code>: <a href="#Rounding">Rounding</a>
 <li><code>FE_TOWARDZERO</code>: <a href="#Rounding">Rounding</a>
-<li><code>FE_UNDERFLOW</code>: <a href="#Status%20bit%20operations">Status bit operations</a>
+<li><code>FE_UNDERFLOW</code>: <a href="#Status bit operations">Status bit operations</a>
 <li><code>FE_UPWARD</code>: <a href="#Rounding">Rounding</a>
-<li><code>FILENAME_MAX</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>FLT_DIG</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_EPSILON</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_MANT_DIG</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_MAX</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_MAX_10_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_MAX_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_MIN</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_MIN_10_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_MIN_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_RADIX</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLT_ROUNDS</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>FLUSHO</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>FOPEN_MAX</code>: <a href="#Opening%20Streams">Opening Streams</a>
-<li><code>FP_FAST_FMA</code>: <a href="#Misc%20FP%20Arithmetic">Misc FP Arithmetic</a>
-<li><code>FP_ILOGB0</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>FP_ILOGBNAN</code>: <a href="#Exponents%20and%20Logarithms">Exponents and Logarithms</a>
-<li><code>FP_INFINITE</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>FP_NAN</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>FP_NORMAL</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>FP_SUBNORMAL</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>FP_ZERO</code>: <a href="#Floating%20Point%20Classes">Floating Point Classes</a>
-<li><code>FPE_DECOVF_TRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>FPE_FLTDIV_TRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>FPE_FLTOVF_TRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>FPE_FLTUND_TRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>FPE_INTDIV_TRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>FPE_INTOVF_TRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>FPE_SUBRNG_TRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>FRAC_DIGITS</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>FSETLOCKING_BYCALLER</code>: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><code>FSETLOCKING_INTERNAL</code>: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><code>FSETLOCKING_QUERY</code>: <a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><code>FSTAB</code>: <a href="#Mount%20Information">Mount Information</a>
+<li><code>FILENAME_MAX</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>FLT_DIG</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_EPSILON</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_MANT_DIG</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_MAX</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_MAX_10_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_MAX_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_MIN</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_MIN_10_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_MIN_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_RADIX</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLT_ROUNDS</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>FLUSHO</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>FOPEN_MAX</code>: <a href="#Opening Streams">Opening Streams</a>
+<li><code>FP_FAST_FMA</code>: <a href="#Misc FP Arithmetic">Misc FP Arithmetic</a>
+<li><code>FP_ILOGB0</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>FP_ILOGBNAN</code>: <a href="#Exponents and Logarithms">Exponents and Logarithms</a>
+<li><code>FP_INFINITE</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>FP_NAN</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>FP_NORMAL</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>FP_SUBNORMAL</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>FP_ZERO</code>: <a href="#Floating Point Classes">Floating Point Classes</a>
+<li><code>FPE_DECOVF_TRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>FPE_FLTDIV_TRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>FPE_FLTOVF_TRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>FPE_FLTUND_TRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>FPE_INTDIV_TRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>FPE_INTOVF_TRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>FPE_SUBRNG_TRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>FRAC_DIGITS</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>FSETLOCKING_BYCALLER</code>: <a href="#Streams and Threads">Streams and Threads</a>
+<li><code>FSETLOCKING_INTERNAL</code>: <a href="#Streams and Threads">Streams and Threads</a>
+<li><code>FSETLOCKING_QUERY</code>: <a href="#Streams and Threads">Streams and Threads</a>
+<li><code>FSTAB</code>: <a href="#Mount Information">Mount Information</a>
 <li><code>FSTAB_RO</code>: <a href="#fstab">fstab</a>
 <li><code>FSTAB_RQ</code>: <a href="#fstab">fstab</a>
 <li><code>FSTAB_RW</code>: <a href="#fstab">fstab</a>
 <li><code>FSTAB_SW</code>: <a href="#fstab">fstab</a>
 <li><code>FSTAB_XX</code>: <a href="#fstab">fstab</a>
-<li><code>FTW_CHDIR</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_D</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_DEPTH</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_DNR</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_DP</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_F</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_MOUNT</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_NS</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_PHYS</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_SL</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>FTW_SLN</code>: <a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><code>getdate_err</code>: <a href="#General%20Time%20String%20Parsing">General Time String Parsing</a>
-<li><code>GLOB_ABORTED</code>: <a href="#Calling%20Glob">Calling Glob</a>
-<li><code>GLOB_ALTDIRFUNC</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>GLOB_APPEND</code>: <a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><code>GLOB_BRACE</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>GLOB_DOOFFS</code>: <a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><code>GLOB_ERR</code>: <a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><code>GLOB_MAGCHAR</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>GLOB_MARK</code>: <a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><code>GLOB_NOCHECK</code>: <a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><code>GLOB_NOESCAPE</code>: <a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><code>GLOB_NOMAGIC</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>GLOB_NOMATCH</code>: <a href="#Calling%20Glob">Calling Glob</a>
-<li><code>GLOB_NOSORT</code>: <a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><code>GLOB_NOSPACE</code>: <a href="#Calling%20Glob">Calling Glob</a>
-<li><code>GLOB_ONLYDIR</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>GLOB_PERIOD</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>GLOB_TILDE</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>GLOB_TILDE_CHECK</code>: <a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
-<li><code>group</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>GROUPING</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>h_errno</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>HOST_NOT_FOUND</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>hosts</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>HUGE_VAL</code>: <a href="#Math%20Error%20Reporting">Math Error Reporting</a>
-<li><code>HUGE_VALF</code>: <a href="#Math%20Error%20Reporting">Math Error Reporting</a>
-<li><code>HUGE_VALL</code>: <a href="#Math%20Error%20Reporting">Math Error Reporting</a>
-<li><code>HUPCL</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>I</code>: <a href="#Complex%20Numbers">Complex Numbers</a>
-<li><code>ICANON</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ICRNL</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>IEXTEN</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>IFNAMSIZ</code>: <a href="#Interface%20Naming">Interface Naming</a>
-<li><code>IGNBRK</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>IGNCR</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>IGNPAR</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>IMAXBEL</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>in6addr_any</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><code>in6addr_loopback</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><code>INADDR_ANY</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><code>INADDR_BROADCAST</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><code>INADDR_LOOPBACK</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><code>INADDR_NONE</code>: <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><code>INFINITY</code>: <a href="#Infinity%20and%20NaN">Infinity and NaN</a>
-<li><code>INIT_PROCESS</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>INLCR</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>INPCK</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>INT_CURR_SYMBOL</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>INT_FRAC_DIGITS</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>INT_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>INT_MIN</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>INT_N_CS_PRECEDES</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>INT_N_SEP_BY_SPACE</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>INT_N_SIGN_POSN</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>INT_P_CS_PRECEDES</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>INT_P_SEP_BY_SPACE</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>INT_P_SIGN_POSN</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
+<li><code>FTW_CHDIR</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_D</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_DEPTH</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_DNR</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_DP</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_F</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_MOUNT</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_NS</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_PHYS</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_SL</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>FTW_SLN</code>: <a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><code>getdate_err</code>: <a href="#General Time String Parsing">General Time String Parsing</a>
+<li><code>GLOB_ABORTED</code>: <a href="#Calling Glob">Calling Glob</a>
+<li><code>GLOB_ALTDIRFUNC</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>GLOB_APPEND</code>: <a href="#Flags for Globbing">Flags for Globbing</a>
+<li><code>GLOB_BRACE</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>GLOB_DOOFFS</code>: <a href="#Flags for Globbing">Flags for Globbing</a>
+<li><code>GLOB_ERR</code>: <a href="#Flags for Globbing">Flags for Globbing</a>
+<li><code>GLOB_MAGCHAR</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>GLOB_MARK</code>: <a href="#Flags for Globbing">Flags for Globbing</a>
+<li><code>GLOB_NOCHECK</code>: <a href="#Flags for Globbing">Flags for Globbing</a>
+<li><code>GLOB_NOESCAPE</code>: <a href="#Flags for Globbing">Flags for Globbing</a>
+<li><code>GLOB_NOMAGIC</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>GLOB_NOMATCH</code>: <a href="#Calling Glob">Calling Glob</a>
+<li><code>GLOB_NOSORT</code>: <a href="#Flags for Globbing">Flags for Globbing</a>
+<li><code>GLOB_NOSPACE</code>: <a href="#Calling Glob">Calling Glob</a>
+<li><code>GLOB_ONLYDIR</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>GLOB_PERIOD</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>GLOB_TILDE</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>GLOB_TILDE_CHECK</code>: <a href="#More Flags for Globbing">More Flags for Globbing</a>
+<li><code>group</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>GROUPING</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>h_errno</code>: <a href="#Host Names">Host Names</a>
+<li><code>HOST_NOT_FOUND</code>: <a href="#Host Names">Host Names</a>
+<li><code>hosts</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>HUGE_VAL</code>: <a href="#Math Error Reporting">Math Error Reporting</a>
+<li><code>HUGE_VALF</code>: <a href="#Math Error Reporting">Math Error Reporting</a>
+<li><code>HUGE_VALL</code>: <a href="#Math Error Reporting">Math Error Reporting</a>
+<li><code>HUPCL</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>I</code>: <a href="#Complex Numbers">Complex Numbers</a>
+<li><code>ICANON</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ICRNL</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>IEXTEN</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>IFNAMSIZ</code>: <a href="#Interface Naming">Interface Naming</a>
+<li><code>IGNBRK</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>IGNCR</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>IGNPAR</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>IMAXBEL</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>in6addr_any</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
+<li><code>in6addr_loopback</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
+<li><code>INADDR_ANY</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
+<li><code>INADDR_BROADCAST</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
+<li><code>INADDR_LOOPBACK</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
+<li><code>INADDR_NONE</code>: <a href="#Host Address Data Type">Host Address Data Type</a>
+<li><code>INFINITY</code>: <a href="#Infinity and NaN">Infinity and NaN</a>
+<li><code>INIT_PROCESS</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>INLCR</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>INPCK</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>INT_CURR_SYMBOL</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>INT_FRAC_DIGITS</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>INT_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>INT_MIN</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>INT_N_CS_PRECEDES</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>INT_N_SEP_BY_SPACE</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>INT_N_SIGN_POSN</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>INT_P_CS_PRECEDES</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>INT_P_SEP_BY_SPACE</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>INT_P_SIGN_POSN</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
 <li><code>IPPORT_RESERVED</code>: <a href="#Ports">Ports</a>
 <li><code>IPPORT_USERRESERVED</code>: <a href="#Ports">Ports</a>
-<li><code>ISIG</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>ISTRIP</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>ITIMER_PROF</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>ITIMER_REAL</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>ITIMER_VIRTUAL</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>
-<li><code>IXANY</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>IXOFF</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>IXON</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>L_ctermid</code>: <a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>
-<li><code>L_cuserid</code>: <a href="#Who%20Logged%20In">Who Logged In</a>
-<li><code>L_INCR</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>L_SET</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>L_tmpnam</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>L_XTND</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>LANG</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LANGUAGE</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LC_ALL</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LC_COLLATE</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LC_CTYPE</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LC_MESSAGES</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LC_MONETARY</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LC_NUMERIC</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LC_TIME</code>: <a href="#Locale%20Categories">Locale Categories</a>
-<li><code>LDBL_DIG</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_EPSILON</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_MANT_DIG</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_MAX</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_MAX_10_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_MAX_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_MIN</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_MIN_10_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LDBL_MIN_EXP</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>LINE_MAX</code>: <a href="#Utility%20Limits">Utility Limits</a>
-<li><code>LINK_MAX</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>LIO_NOP</code>: <a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
-<li><code>LIO_READ</code>: <a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
-<li><code>LIO_WRITE</code>: <a href="#Asynchronous%20I%2fO">Asynchronous I/O</a>
-<li><code>LOG_ALERT</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_AUTH</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_AUTHPRIV</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_CRIT</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_CRON</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_DAEMON</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_DEBUG</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_EMERG</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_ERR</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_FTP</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_INFO</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL0</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL1</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL2</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL3</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL4</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL5</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL6</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LOCAL7</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_LPR</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_MAIL</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_NEWS</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_NOTICE</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_SYSLOG</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_USER</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_UUCP</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOG_WARNING</code>: <a href="#syslog%3b%20vsyslog">syslog; vsyslog</a>
-<li><code>LOGIN_PROCESS</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>LONG_LONG_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>LONG_LONG_MIN</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>LONG_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>LONG_MIN</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>M_1_PI</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_2_PI</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_2_SQRTPI</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_E</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_LN10</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_LN2</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_LOG10E</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_LOG2E</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_PI</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_PI_2</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_PI_4</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_SQRT1_2</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>M_SQRT2</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>MAP_ANON</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>MAP_ANONYMOUS</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>MAP_FIXED</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>MAP_PRIVATE</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>MAP_SHARED</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>MAX_CANON</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>MAX_INPUT</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>MAXNAMLEN</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>MAXSYMLINKS</code>: <a href="#Symbolic%20Links">Symbolic Links</a>
-<li><code>MB_CUR_MAX</code>: <a href="#Selecting%20the%20Conversion">Selecting the Conversion</a>
-<li><code>MB_LEN_MAX</code>: <a href="#Selecting%20the%20Conversion">Selecting the Conversion</a>
-<li><code>MDMBUF</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>MINSIGSTKSZ</code>: <a href="#Signal%20Stack">Signal Stack</a>
-<li><code>MM_APPL</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_CONSOLE</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_ERROR</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_FIRM</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_HALT</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_HARD</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_INFO</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NOSEV</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NRECOV</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NULLACT</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NULLLBL</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NULLMC</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NULLSEV</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NULLTAG</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_NULLTXT</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_OPSYS</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_PRINT</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_RECOVER</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_SOFT</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_UTIL</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><code>MM_WARNING</code>: <a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
+<li><code>ISIG</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>ISTRIP</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>ITIMER_PROF</code>: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>ITIMER_REAL</code>: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>ITIMER_VIRTUAL</code>: <a href="#Setting an Alarm">Setting an Alarm</a>
+<li><code>IXANY</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>IXOFF</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>IXON</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>L_ctermid</code>: <a href="#Identifying the Terminal">Identifying the Terminal</a>
+<li><code>L_cuserid</code>: <a href="#Who Logged In">Who Logged In</a>
+<li><code>L_INCR</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>L_SET</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>L_tmpnam</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>L_XTND</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>LANG</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LANGUAGE</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LC_ALL</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LC_COLLATE</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LC_CTYPE</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LC_MESSAGES</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LC_MONETARY</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LC_NUMERIC</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LC_TIME</code>: <a href="#Locale Categories">Locale Categories</a>
+<li><code>LDBL_DIG</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_EPSILON</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_MANT_DIG</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_MAX</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_MAX_10_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_MAX_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_MIN</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_MIN_10_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LDBL_MIN_EXP</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>LINE_MAX</code>: <a href="#Utility Limits">Utility Limits</a>
+<li><code>LINK_MAX</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>LIO_NOP</code>: <a href="#Asynchronous I%2fO">Asynchronous I/O</a>
+<li><code>LIO_READ</code>: <a href="#Asynchronous I%2fO">Asynchronous I/O</a>
+<li><code>LIO_WRITE</code>: <a href="#Asynchronous I%2fO">Asynchronous I/O</a>
+<li><code>LOG_ALERT</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_AUTH</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_AUTHPRIV</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_CRIT</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_CRON</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_DAEMON</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_DEBUG</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_EMERG</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_ERR</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_FTP</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_INFO</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL0</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL1</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL2</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL3</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL4</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL5</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL6</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LOCAL7</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_LPR</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_MAIL</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_NEWS</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_NOTICE</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_SYSLOG</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_USER</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_UUCP</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOG_WARNING</code>: <a href="#syslog%3b vsyslog">syslog; vsyslog</a>
+<li><code>LOGIN_PROCESS</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>LONG_LONG_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>LONG_LONG_MIN</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>LONG_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>LONG_MIN</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>M_1_PI</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_2_PI</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_2_SQRTPI</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_E</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_LN10</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_LN2</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_LOG10E</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_LOG2E</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_PI</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_PI_2</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_PI_4</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_SQRT1_2</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>M_SQRT2</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>MAP_ANON</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>MAP_ANONYMOUS</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>MAP_FIXED</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>MAP_PRIVATE</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>MAP_SHARED</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>MAX_CANON</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>MAX_INPUT</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>MAXNAMLEN</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>MAXSYMLINKS</code>: <a href="#Symbolic Links">Symbolic Links</a>
+<li><code>MB_CUR_MAX</code>: <a href="#Selecting the Conversion">Selecting the Conversion</a>
+<li><code>MB_LEN_MAX</code>: <a href="#Selecting the Conversion">Selecting the Conversion</a>
+<li><code>MDMBUF</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>MINSIGSTKSZ</code>: <a href="#Signal Stack">Signal Stack</a>
+<li><code>MM_APPL</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_CONSOLE</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_ERROR</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_FIRM</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_HALT</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_HARD</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_INFO</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NOSEV</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NRECOV</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NULLACT</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NULLLBL</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NULLMC</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NULLSEV</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NULLTAG</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_NULLTXT</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_OPSYS</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_PRINT</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_RECOVER</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_SOFT</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_UTIL</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><code>MM_WARNING</code>: <a href="#Printing Formatted Messages">Printing Formatted Messages</a>
 <li><code>MNTOPT_DEFAULTS</code>: <a href="#mtab">mtab</a>
 <li><code>MNTOPT_NOAUTO</code>: <a href="#mtab">mtab</a>
 <li><code>MNTOPT_NOSUID</code>: <a href="#mtab">mtab</a>
 <li><code>MNTOPT_RO</code>: <a href="#mtab">mtab</a>
@@ -91413,455 +89804,455 @@
 <li><code>MNTOPT_SUID</code>: <a href="#mtab">mtab</a>
 <li><code>MNTTYPE_IGNORE</code>: <a href="#mtab">mtab</a>
 <li><code>MNTTYPE_NFS</code>: <a href="#mtab">mtab</a>
 <li><code>MNTTYPE_SWAP</code>: <a href="#mtab">mtab</a>
-<li><code>MON_1</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_10</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_11</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_12</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_2</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_3</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_4</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_5</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_6</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_7</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_8</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_9</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_DECIMAL_POINT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_GROUPING</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MON_THOUSANDS_SEP</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>MS_ASYNC</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>MS_SYNC</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>MSG_DONTROUTE</code>: <a href="#Socket%20Data%20Options">Socket Data Options</a>
-<li><code>MSG_OOB</code>: <a href="#Socket%20Data%20Options">Socket Data Options</a>
-<li><code>MSG_PEEK</code>: <a href="#Socket%20Data%20Options">Socket Data Options</a>
-<li><code>N_CS_PRECEDES</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>N_SEP_BY_SPACE</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>N_SIGN_POSN</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>NAME_MAX</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>NAN</code>: <a href="#Infinity%20and%20NaN">Infinity and NaN</a>
-<li><code>NCCS</code>: <a href="#Mode%20Data%20Types">Mode Data Types</a>
-<li><code>NDEBUG</code>: <a href="#Consistency%20Checking">Consistency Checking</a>
-<li><code>NEGATIVE_SIGN</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>netgroup</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>networks</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>NEW_TIME</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>NGROUPS_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>NL_ARGMAX</code>: <a href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>
-<li><code>NO_ADDRESS</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>NO_RECOVERY</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>NOEXPR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>NOFLSH</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>NOKERNINFO</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>NOSTR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>NSIG</code>: <a href="#Standard%20Signals">Standard Signals</a>
-<li><code>NSS_STATUS_NOTFOUND</code>: <a href="#NSS%20Modules%20Interface">NSS Modules Interface</a>
-<li><code>NSS_STATUS_SUCCESS</code>: <a href="#NSS%20Modules%20Interface">NSS Modules Interface</a>
-<li><code>NSS_STATUS_TRYAGAIN</code>: <a href="#NSS%20Modules%20Interface">NSS Modules Interface</a>
-<li><code>NSS_STATUS_UNAVAIL</code>: <a href="#NSS%20Modules%20Interface">NSS Modules Interface</a>
-<li><code>NULL</code>: <a href="#Null%20Pointer%20Constant">Null Pointer Constant</a>
-<li><code>O_ACCMODE</code>: <a href="#Access%20Modes">Access Modes</a>
-<li><code>O_APPEND</code>: <a href="#Operating%20Modes">Operating Modes</a>
-<li><code>O_ASYNC</code>: <a href="#Operating%20Modes">Operating Modes</a>
-<li><code>O_CREAT</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_EXCL</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_EXEC</code>: <a href="#Access%20Modes">Access Modes</a>
-<li><code>O_EXLOCK</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_FSYNC</code>: <a href="#Operating%20Modes">Operating Modes</a>
-<li><code>O_IGNORE_CTTY</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_NDELAY</code>: <a href="#Operating%20Modes">Operating Modes</a>
-<li><code>O_NOATIME</code>: <a href="#Operating%20Modes">Operating Modes</a>
-<li><code>O_NOCTTY</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_NOLINK</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_NONBLOCK</code>: <a href="#Operating%20Modes">Operating Modes</a>, <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_NOTRANS</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_RDONLY</code>: <a href="#Access%20Modes">Access Modes</a>
-<li><code>O_RDWR</code>: <a href="#Access%20Modes">Access Modes</a>
-<li><code>O_READ</code>: <a href="#Access%20Modes">Access Modes</a>
-<li><code>O_SHLOCK</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_SYNC</code>: <a href="#Operating%20Modes">Operating Modes</a>
-<li><code>O_TRUNC</code>: <a href="#Open-time%20Flags">Open-time Flags</a>
-<li><code>O_WRITE</code>: <a href="#Access%20Modes">Access Modes</a>
-<li><code>O_WRONLY</code>: <a href="#Access%20Modes">Access Modes</a>
-<li><code>obstack_alloc_failed_handler</code>: <a href="#Preparing%20for%20Obstacks">Preparing for Obstacks</a>
-<li><code>OLD_TIME</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>ONLCR</code>: <a href="#Output%20Modes">Output Modes</a>
-<li><code>ONOEOT</code>: <a href="#Output%20Modes">Output Modes</a>
-<li><code>OPEN_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>OPOST</code>: <a href="#Output%20Modes">Output Modes</a>
-<li><code>optarg</code>: <a href="#Using%20Getopt">Using Getopt</a>
-<li><code>opterr</code>: <a href="#Using%20Getopt">Using Getopt</a>
-<li><code>optind</code>: <a href="#Using%20Getopt">Using Getopt</a>
-<li><code>OPTION_ALIAS</code>: <a href="#Argp%20Option%20Flags">Argp Option Flags</a>
-<li><code>OPTION_ARG_OPTIONAL</code>: <a href="#Argp%20Option%20Flags">Argp Option Flags</a>
-<li><code>OPTION_DOC</code>: <a href="#Argp%20Option%20Flags">Argp Option Flags</a>
-<li><code>OPTION_HIDDEN</code>: <a href="#Argp%20Option%20Flags">Argp Option Flags</a>
-<li><code>OPTION_NO_USAGE</code>: <a href="#Argp%20Option%20Flags">Argp Option Flags</a>
-<li><code>optopt</code>: <a href="#Using%20Getopt">Using Getopt</a>
-<li><code>OXTABS</code>: <a href="#Output%20Modes">Output Modes</a>
-<li><code>P_CS_PRECEDES</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>P_SEP_BY_SPACE</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>P_SIGN_POSN</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>P_tmpdir</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>PA_CHAR</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_DOUBLE</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_FLAG_LONG</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_FLAG_LONG_DOUBLE</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_FLAG_LONG_LONG</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_FLAG_MASK</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_FLAG_PTR</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_FLAG_SHORT</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_FLOAT</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_INT</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_LAST</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_POINTER</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PA_STRING</code>: <a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><code>PARENB</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>PARMRK</code>: <a href="#Input%20Modes">Input Modes</a>
-<li><code>PARODD</code>: <a href="#Control%20Modes">Control Modes</a>
-<li><code>passwd</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>PATH_MAX</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>PENDIN</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>PF_CCITT</code>: <a href="#Misc%20Namespaces">Misc Namespaces</a>
-<li><code>PF_FILE</code>: <a href="#Local%20Namespace%20Details">Local Namespace Details</a>
-<li><code>PF_IMPLINK</code>: <a href="#Misc%20Namespaces">Misc Namespaces</a>
-<li><code>PF_INET</code>: <a href="#Internet%20Namespace">Internet Namespace</a>
-<li><code>PF_INET6</code>: <a href="#Internet%20Namespace">Internet Namespace</a>
-<li><code>PF_ISO</code>: <a href="#Misc%20Namespaces">Misc Namespaces</a>
-<li><code>PF_LOCAL</code>: <a href="#Local%20Namespace%20Details">Local Namespace Details</a>
-<li><code>PF_NS</code>: <a href="#Misc%20Namespaces">Misc Namespaces</a>
-<li><code>PF_ROUTE</code>: <a href="#Misc%20Namespaces">Misc Namespaces</a>
-<li><code>PF_UNIX</code>: <a href="#Local%20Namespace%20Details">Local Namespace Details</a>
-<li><code>PI</code>: <a href="#Mathematical%20Constants">Mathematical Constants</a>
-<li><code>PIPE_BUF</code>: <a href="#Limits%20for%20Files">Limits for Files</a>
-<li><code>PM_STR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>POSITIVE_SIGN</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>PRIO_MAX</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>PRIO_MIN</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>PRIO_PGRP</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>PRIO_PROCESS</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>PRIO_USER</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>
-<li><code>program_invocation_name</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>program_invocation_short_name</code>: <a href="#Error%20Messages">Error Messages</a>
-<li><code>PROT_EXEC</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>PROT_READ</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>PROT_WRITE</code>: <a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><code>protocols</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>PWD</code>: <a href="#Working%20Directory">Working Directory</a>
-<li><code>R_OK</code>: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li><code>RADIXCHAR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>RAND_MAX</code>: <a href="#ISO%20Random">ISO Random</a>
-<li><code>RE_DUP_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>RLIM_INFINITY</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIM_NLIMITS</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_AS</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_CORE</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_CPU</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_DATA</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_FSIZE</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_NOFILE</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_OFILE</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_RSS</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>RLIMIT_STACK</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>rpc</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>RUN_LVL</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>S_IEXEC</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IFBLK</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IFCHR</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IFDIR</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IFIFO</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IFLNK</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IFMT</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IFREG</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IFSOCK</code>: <a href="#Testing%20File%20Type">Testing File Type</a>
-<li><code>S_IREAD</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IRGRP</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IROTH</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IRUSR</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IRWXG</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IRWXO</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IRWXU</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_ISGID</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_ISUID</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_ISVTX</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IWGRP</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IWOTH</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IWRITE</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IWUSR</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IXGRP</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IXOTH</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>S_IXUSR</code>: <a href="#Permission%20Bits">Permission Bits</a>
-<li><code>SA_NOCLDSTOP</code>: <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>
-<li><code>SA_ONSTACK</code>: <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>
-<li><code>SA_RESTART</code>: <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>
-<li><code>SC_SSIZE_MAX</code>: <a href="#Constants%20for%20Sysconf">Constants for Sysconf</a>
-<li><code>SCHAR_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>SCHAR_MIN</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>SEEK_CUR</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>SEEK_END</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>SEEK_SET</code>: <a href="#File%20Positioning">File Positioning</a>
-<li><code>services</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>shadow</code>: <a href="#NSS%20Basics">NSS Basics</a>
-<li><code>SHRT_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>SHRT_MIN</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>SIG_BLOCK</code>: <a href="#Process%20Signal%20Mask">Process Signal Mask</a>
-<li><code>SIG_DFL</code>: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><code>SIG_ERR</code>: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><code>SIG_IGN</code>: <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><code>SIG_SETMASK</code>: <a href="#Process%20Signal%20Mask">Process Signal Mask</a>
-<li><code>SIG_UNBLOCK</code>: <a href="#Process%20Signal%20Mask">Process Signal Mask</a>
-<li><code>SIGABRT</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGALRM</code>: <a href="#Alarm%20Signals">Alarm Signals</a>
-<li><code>SIGBUS</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGCHLD</code>: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><code>SIGCLD</code>: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><code>SIGCONT</code>: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><code>SIGEMT</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGFPE</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGHUP</code>: <a href="#Termination%20Signals">Termination Signals</a>
-<li><code>SIGILL</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGINFO</code>: <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>
-<li><code>SIGINT</code>: <a href="#Termination%20Signals">Termination Signals</a>
-<li><code>SIGIO</code>: <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>
-<li><code>SIGIOT</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGKILL</code>: <a href="#Termination%20Signals">Termination Signals</a>
-<li><code>SIGLOST</code>: <a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li><code>signgam</code>: <a href="#Special%20Functions">Special Functions</a>
-<li><code>SIGPIPE</code>: <a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li><code>SIGPOLL</code>: <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>
-<li><code>SIGPROF</code>: <a href="#Alarm%20Signals">Alarm Signals</a>
-<li><code>SIGQUIT</code>: <a href="#Termination%20Signals">Termination Signals</a>
-<li><code>SIGSEGV</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGSTKSZ</code>: <a href="#Signal%20Stack">Signal Stack</a>
-<li><code>SIGSTOP</code>: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><code>SIGSYS</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGTERM</code>: <a href="#Termination%20Signals">Termination Signals</a>
-<li><code>SIGTRAP</code>: <a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><code>SIGTSTP</code>: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><code>SIGTTIN</code>: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><code>SIGTTOU</code>: <a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><code>SIGURG</code>: <a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>
-<li><code>SIGUSR1</code>: <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>
-<li><code>SIGUSR2</code>: <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>
-<li><code>SIGVTALRM</code>: <a href="#Alarm%20Signals">Alarm Signals</a>
-<li><code>SIGWINCH</code>: <a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>
-<li><code>SIGXCPU</code>: <a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li><code>SIGXFSZ</code>: <a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li><code>SOCK_DGRAM</code>: <a href="#Communication%20Styles">Communication Styles</a>
-<li><code>SOCK_RAW</code>: <a href="#Communication%20Styles">Communication Styles</a>
-<li><code>SOCK_STREAM</code>: <a href="#Communication%20Styles">Communication Styles</a>
-<li><code>SOL_SOCKET</code>: <a href="#Socket-Level%20Options">Socket-Level Options</a>
-<li><code>SS_DISABLE</code>: <a href="#Signal%20Stack">Signal Stack</a>
-<li><code>SS_ONSTACK</code>: <a href="#Signal%20Stack">Signal Stack</a>
-<li><code>SSIZE_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>stderr</code>: <a href="#Standard%20Streams">Standard Streams</a>
-<li><code>STDERR_FILENO</code>: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><code>stdin</code>: <a href="#Standard%20Streams">Standard Streams</a>
-<li><code>STDIN_FILENO</code>: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><code>stdout</code>: <a href="#Standard%20Streams">Standard Streams</a>
-<li><code>STDOUT_FILENO</code>: <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><code>STREAM_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>SV_INTERRUPT</code>: <a href="#BSD%20Handler">BSD Handler</a>
-<li><code>SV_ONSTACK</code>: <a href="#BSD%20Handler">BSD Handler</a>
-<li><code>SV_RESETHAND</code>: <a href="#BSD%20Handler">BSD Handler</a>
-<li><code>sys_siglist</code>: <a href="#Signal%20Messages">Signal Messages</a>
-<li><code>T_FMT</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>T_FMT_AMPM</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>TCIFLUSH</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>TCIOFF</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>TCIOFLUSH</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>TCION</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>TCOFLUSH</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>TCOOFF</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>TCOON</code>: <a href="#Line%20Control">Line Control</a>
-<li><code>TCSADRAIN</code>: <a href="#Mode%20Functions">Mode Functions</a>
-<li><code>TCSAFLUSH</code>: <a href="#Mode%20Functions">Mode Functions</a>
-<li><code>TCSANOW</code>: <a href="#Mode%20Functions">Mode Functions</a>
-<li><code>TCSASOFT</code>: <a href="#Mode%20Functions">Mode Functions</a>
-<li><code>THOUSANDS_SEP</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>THOUSEP</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>timezone</code>: <a href="#Time%20Zone%20Functions">Time Zone Functions</a>
-<li><code>TMP_MAX</code>: <a href="#Temporary%20Files">Temporary Files</a>
-<li><code>TOSTOP</code>: <a href="#Local%20Modes">Local Modes</a>
-<li><code>TRY_AGAIN</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>tzname</code>: <a href="#Time%20Zone%20Functions">Time Zone Functions</a>
-<li><code>TZNAME_MAX</code>: <a href="#General%20Limits">General Limits</a>
-<li><code>UCHAR_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>UINT_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>ULONG_LONG_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>ULONG_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>USER_PROCESS</code>: <a href="#XPG%20Functions">XPG Functions</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>USHRT_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>
-<li><code>VDISCARD</code>: <a href="#Other%20Special">Other Special</a>
-<li><code>VDSUSP</code>: <a href="#Signal%20Characters">Signal Characters</a>
-<li><code>VEOF</code>: <a href="#Editing%20Characters">Editing Characters</a>
-<li><code>VEOL</code>: <a href="#Editing%20Characters">Editing Characters</a>
-<li><code>VEOL2</code>: <a href="#Editing%20Characters">Editing Characters</a>
-<li><code>VERASE</code>: <a href="#Editing%20Characters">Editing Characters</a>
-<li><code>VINTR</code>: <a href="#Signal%20Characters">Signal Characters</a>
-<li><code>VKILL</code>: <a href="#Editing%20Characters">Editing Characters</a>
-<li><code>VLNEXT</code>: <a href="#Other%20Special">Other Special</a>
-<li><code>VMIN</code>: <a href="#Noncanonical%20Input">Noncanonical Input</a>
-<li><code>VQUIT</code>: <a href="#Signal%20Characters">Signal Characters</a>
-<li><code>VREPRINT</code>: <a href="#Editing%20Characters">Editing Characters</a>
-<li><code>VSTART</code>: <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>
-<li><code>VSTATUS</code>: <a href="#Other%20Special">Other Special</a>
-<li><code>VSTOP</code>: <a href="#Start%2fStop%20Characters">Start/Stop Characters</a>
-<li><code>VSUSP</code>: <a href="#Signal%20Characters">Signal Characters</a>
-<li><code>VTIME</code>: <a href="#Noncanonical%20Input">Noncanonical Input</a>
-<li><code>VWERASE</code>: <a href="#Editing%20Characters">Editing Characters</a>
-<li><code>W_OK</code>: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li><code>WCHAR_MAX</code>: <a href="#Range%20of%20Type">Range of Type</a>, <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li><code>WCHAR_MIN</code>: <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li><code>WEOF</code>: <a href="#EOF%20and%20Errors">EOF and Errors</a>, <a href="#Extended%20Char%20Intro">Extended Char Intro</a>
-<li><code>X_OK</code>: <a href="#Testing%20File%20Access">Testing File Access</a>
-<li><code>YESEXPR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>YESSTR</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
+<li><code>MON_1</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_10</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_11</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_12</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_2</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_3</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_4</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_5</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_6</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_7</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_8</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_9</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_DECIMAL_POINT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_GROUPING</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MON_THOUSANDS_SEP</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>MS_ASYNC</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>MS_SYNC</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>MSG_DONTROUTE</code>: <a href="#Socket Data Options">Socket Data Options</a>
+<li><code>MSG_OOB</code>: <a href="#Socket Data Options">Socket Data Options</a>
+<li><code>MSG_PEEK</code>: <a href="#Socket Data Options">Socket Data Options</a>
+<li><code>N_CS_PRECEDES</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>N_SEP_BY_SPACE</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>N_SIGN_POSN</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>NAME_MAX</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>NAN</code>: <a href="#Infinity and NaN">Infinity and NaN</a>
+<li><code>NCCS</code>: <a href="#Mode Data Types">Mode Data Types</a>
+<li><code>NDEBUG</code>: <a href="#Consistency Checking">Consistency Checking</a>
+<li><code>NEGATIVE_SIGN</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>netgroup</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>networks</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>NEW_TIME</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>NGROUPS_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>NL_ARGMAX</code>: <a href="#Output Conversion Syntax">Output Conversion Syntax</a>
+<li><code>NO_ADDRESS</code>: <a href="#Host Names">Host Names</a>
+<li><code>NO_RECOVERY</code>: <a href="#Host Names">Host Names</a>
+<li><code>NOEXPR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>NOFLSH</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>NOKERNINFO</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>NOSTR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>NSIG</code>: <a href="#Standard Signals">Standard Signals</a>
+<li><code>NSS_STATUS_NOTFOUND</code>: <a href="#NSS Modules Interface">NSS Modules Interface</a>
+<li><code>NSS_STATUS_SUCCESS</code>: <a href="#NSS Modules Interface">NSS Modules Interface</a>
+<li><code>NSS_STATUS_TRYAGAIN</code>: <a href="#NSS Modules Interface">NSS Modules Interface</a>
+<li><code>NSS_STATUS_UNAVAIL</code>: <a href="#NSS Modules Interface">NSS Modules Interface</a>
+<li><code>NULL</code>: <a href="#Null Pointer Constant">Null Pointer Constant</a>
+<li><code>O_ACCMODE</code>: <a href="#Access Modes">Access Modes</a>
+<li><code>O_APPEND</code>: <a href="#Operating Modes">Operating Modes</a>
+<li><code>O_ASYNC</code>: <a href="#Operating Modes">Operating Modes</a>
+<li><code>O_CREAT</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_EXCL</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_EXEC</code>: <a href="#Access Modes">Access Modes</a>
+<li><code>O_EXLOCK</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_FSYNC</code>: <a href="#Operating Modes">Operating Modes</a>
+<li><code>O_IGNORE_CTTY</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_NDELAY</code>: <a href="#Operating Modes">Operating Modes</a>
+<li><code>O_NOATIME</code>: <a href="#Operating Modes">Operating Modes</a>
+<li><code>O_NOCTTY</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_NOLINK</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_NONBLOCK</code>: <a href="#Operating Modes">Operating Modes</a>, <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_NOTRANS</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_RDONLY</code>: <a href="#Access Modes">Access Modes</a>
+<li><code>O_RDWR</code>: <a href="#Access Modes">Access Modes</a>
+<li><code>O_READ</code>: <a href="#Access Modes">Access Modes</a>
+<li><code>O_SHLOCK</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_SYNC</code>: <a href="#Operating Modes">Operating Modes</a>
+<li><code>O_TRUNC</code>: <a href="#Open-time Flags">Open-time Flags</a>
+<li><code>O_WRITE</code>: <a href="#Access Modes">Access Modes</a>
+<li><code>O_WRONLY</code>: <a href="#Access Modes">Access Modes</a>
+<li><code>obstack_alloc_failed_handler</code>: <a href="#Preparing for Obstacks">Preparing for Obstacks</a>
+<li><code>OLD_TIME</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>ONLCR</code>: <a href="#Output Modes">Output Modes</a>
+<li><code>ONOEOT</code>: <a href="#Output Modes">Output Modes</a>
+<li><code>OPEN_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>OPOST</code>: <a href="#Output Modes">Output Modes</a>
+<li><code>optarg</code>: <a href="#Using Getopt">Using Getopt</a>
+<li><code>opterr</code>: <a href="#Using Getopt">Using Getopt</a>
+<li><code>optind</code>: <a href="#Using Getopt">Using Getopt</a>
+<li><code>OPTION_ALIAS</code>: <a href="#Argp Option Flags">Argp Option Flags</a>
+<li><code>OPTION_ARG_OPTIONAL</code>: <a href="#Argp Option Flags">Argp Option Flags</a>
+<li><code>OPTION_DOC</code>: <a href="#Argp Option Flags">Argp Option Flags</a>
+<li><code>OPTION_HIDDEN</code>: <a href="#Argp Option Flags">Argp Option Flags</a>
+<li><code>OPTION_NO_USAGE</code>: <a href="#Argp Option Flags">Argp Option Flags</a>
+<li><code>optopt</code>: <a href="#Using Getopt">Using Getopt</a>
+<li><code>OXTABS</code>: <a href="#Output Modes">Output Modes</a>
+<li><code>P_CS_PRECEDES</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>P_SEP_BY_SPACE</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>P_SIGN_POSN</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>P_tmpdir</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>PA_CHAR</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_DOUBLE</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_FLAG_LONG</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_FLAG_LONG_DOUBLE</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_FLAG_LONG_LONG</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_FLAG_MASK</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_FLAG_PTR</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_FLAG_SHORT</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_FLOAT</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_INT</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_LAST</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_POINTER</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PA_STRING</code>: <a href="#Parsing a Template String">Parsing a Template String</a>
+<li><code>PARENB</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>PARMRK</code>: <a href="#Input Modes">Input Modes</a>
+<li><code>PARODD</code>: <a href="#Control Modes">Control Modes</a>
+<li><code>passwd</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>PATH_MAX</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>PENDIN</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>PF_CCITT</code>: <a href="#Misc Namespaces">Misc Namespaces</a>
+<li><code>PF_FILE</code>: <a href="#Local Namespace Details">Local Namespace Details</a>
+<li><code>PF_IMPLINK</code>: <a href="#Misc Namespaces">Misc Namespaces</a>
+<li><code>PF_INET</code>: <a href="#Internet Namespace">Internet Namespace</a>
+<li><code>PF_INET6</code>: <a href="#Internet Namespace">Internet Namespace</a>
+<li><code>PF_ISO</code>: <a href="#Misc Namespaces">Misc Namespaces</a>
+<li><code>PF_LOCAL</code>: <a href="#Local Namespace Details">Local Namespace Details</a>
+<li><code>PF_NS</code>: <a href="#Misc Namespaces">Misc Namespaces</a>
+<li><code>PF_ROUTE</code>: <a href="#Misc Namespaces">Misc Namespaces</a>
+<li><code>PF_UNIX</code>: <a href="#Local Namespace Details">Local Namespace Details</a>
+<li><code>PI</code>: <a href="#Mathematical Constants">Mathematical Constants</a>
+<li><code>PIPE_BUF</code>: <a href="#Limits for Files">Limits for Files</a>
+<li><code>PM_STR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>POSITIVE_SIGN</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>PRIO_MAX</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>PRIO_MIN</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>PRIO_PGRP</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>PRIO_PROCESS</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>PRIO_USER</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>
+<li><code>program_invocation_name</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>program_invocation_short_name</code>: <a href="#Error Messages">Error Messages</a>
+<li><code>PROT_EXEC</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>PROT_READ</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>PROT_WRITE</code>: <a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><code>protocols</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>PWD</code>: <a href="#Working Directory">Working Directory</a>
+<li><code>R_OK</code>: <a href="#Testing File Access">Testing File Access</a>
+<li><code>RADIXCHAR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>RAND_MAX</code>: <a href="#ISO Random">ISO Random</a>
+<li><code>RE_DUP_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>RLIM_INFINITY</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIM_NLIMITS</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_AS</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_CORE</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_CPU</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_DATA</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_FSIZE</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_NOFILE</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_OFILE</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_RSS</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>RLIMIT_STACK</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>rpc</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>RUN_LVL</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>S_IEXEC</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IFBLK</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IFCHR</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IFDIR</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IFIFO</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IFLNK</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IFMT</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IFREG</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IFSOCK</code>: <a href="#Testing File Type">Testing File Type</a>
+<li><code>S_IREAD</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IRGRP</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IROTH</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IRUSR</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IRWXG</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IRWXO</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IRWXU</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_ISGID</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_ISUID</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_ISVTX</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IWGRP</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IWOTH</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IWRITE</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IWUSR</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IXGRP</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IXOTH</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>S_IXUSR</code>: <a href="#Permission Bits">Permission Bits</a>
+<li><code>SA_NOCLDSTOP</code>: <a href="#Flags for Sigaction">Flags for Sigaction</a>
+<li><code>SA_ONSTACK</code>: <a href="#Flags for Sigaction">Flags for Sigaction</a>
+<li><code>SA_RESTART</code>: <a href="#Flags for Sigaction">Flags for Sigaction</a>
+<li><code>SC_SSIZE_MAX</code>: <a href="#Constants for Sysconf">Constants for Sysconf</a>
+<li><code>SCHAR_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>SCHAR_MIN</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>SEEK_CUR</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>SEEK_END</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>SEEK_SET</code>: <a href="#File Positioning">File Positioning</a>
+<li><code>services</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>shadow</code>: <a href="#NSS Basics">NSS Basics</a>
+<li><code>SHRT_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>SHRT_MIN</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>SIG_BLOCK</code>: <a href="#Process Signal Mask">Process Signal Mask</a>
+<li><code>SIG_DFL</code>: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><code>SIG_ERR</code>: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><code>SIG_IGN</code>: <a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><code>SIG_SETMASK</code>: <a href="#Process Signal Mask">Process Signal Mask</a>
+<li><code>SIG_UNBLOCK</code>: <a href="#Process Signal Mask">Process Signal Mask</a>
+<li><code>SIGABRT</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGALRM</code>: <a href="#Alarm Signals">Alarm Signals</a>
+<li><code>SIGBUS</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGCHLD</code>: <a href="#Job Control Signals">Job Control Signals</a>
+<li><code>SIGCLD</code>: <a href="#Job Control Signals">Job Control Signals</a>
+<li><code>SIGCONT</code>: <a href="#Job Control Signals">Job Control Signals</a>
+<li><code>SIGEMT</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGFPE</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGHUP</code>: <a href="#Termination Signals">Termination Signals</a>
+<li><code>SIGILL</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGINFO</code>: <a href="#Miscellaneous Signals">Miscellaneous Signals</a>
+<li><code>SIGINT</code>: <a href="#Termination Signals">Termination Signals</a>
+<li><code>SIGIO</code>: <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>
+<li><code>SIGIOT</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGKILL</code>: <a href="#Termination Signals">Termination Signals</a>
+<li><code>SIGLOST</code>: <a href="#Operation Error Signals">Operation Error Signals</a>
+<li><code>signgam</code>: <a href="#Special Functions">Special Functions</a>
+<li><code>SIGPIPE</code>: <a href="#Operation Error Signals">Operation Error Signals</a>
+<li><code>SIGPOLL</code>: <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>
+<li><code>SIGPROF</code>: <a href="#Alarm Signals">Alarm Signals</a>
+<li><code>SIGQUIT</code>: <a href="#Termination Signals">Termination Signals</a>
+<li><code>SIGSEGV</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGSTKSZ</code>: <a href="#Signal Stack">Signal Stack</a>
+<li><code>SIGSTOP</code>: <a href="#Job Control Signals">Job Control Signals</a>
+<li><code>SIGSYS</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGTERM</code>: <a href="#Termination Signals">Termination Signals</a>
+<li><code>SIGTRAP</code>: <a href="#Program Error Signals">Program Error Signals</a>
+<li><code>SIGTSTP</code>: <a href="#Job Control Signals">Job Control Signals</a>
+<li><code>SIGTTIN</code>: <a href="#Job Control Signals">Job Control Signals</a>
+<li><code>SIGTTOU</code>: <a href="#Job Control Signals">Job Control Signals</a>
+<li><code>SIGURG</code>: <a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>
+<li><code>SIGUSR1</code>: <a href="#Miscellaneous Signals">Miscellaneous Signals</a>
+<li><code>SIGUSR2</code>: <a href="#Miscellaneous Signals">Miscellaneous Signals</a>
+<li><code>SIGVTALRM</code>: <a href="#Alarm Signals">Alarm Signals</a>
+<li><code>SIGWINCH</code>: <a href="#Miscellaneous Signals">Miscellaneous Signals</a>
+<li><code>SIGXCPU</code>: <a href="#Operation Error Signals">Operation Error Signals</a>
+<li><code>SIGXFSZ</code>: <a href="#Operation Error Signals">Operation Error Signals</a>
+<li><code>SOCK_DGRAM</code>: <a href="#Communication Styles">Communication Styles</a>
+<li><code>SOCK_RAW</code>: <a href="#Communication Styles">Communication Styles</a>
+<li><code>SOCK_STREAM</code>: <a href="#Communication Styles">Communication Styles</a>
+<li><code>SOL_SOCKET</code>: <a href="#Socket-Level Options">Socket-Level Options</a>
+<li><code>SS_DISABLE</code>: <a href="#Signal Stack">Signal Stack</a>
+<li><code>SS_ONSTACK</code>: <a href="#Signal Stack">Signal Stack</a>
+<li><code>SSIZE_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>stderr</code>: <a href="#Standard Streams">Standard Streams</a>
+<li><code>STDERR_FILENO</code>: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><code>stdin</code>: <a href="#Standard Streams">Standard Streams</a>
+<li><code>STDIN_FILENO</code>: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><code>stdout</code>: <a href="#Standard Streams">Standard Streams</a>
+<li><code>STDOUT_FILENO</code>: <a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><code>STREAM_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>SV_INTERRUPT</code>: <a href="#BSD Handler">BSD Handler</a>
+<li><code>SV_ONSTACK</code>: <a href="#BSD Handler">BSD Handler</a>
+<li><code>SV_RESETHAND</code>: <a href="#BSD Handler">BSD Handler</a>
+<li><code>sys_siglist</code>: <a href="#Signal Messages">Signal Messages</a>
+<li><code>T_FMT</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>T_FMT_AMPM</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>TCIFLUSH</code>: <a href="#Line Control">Line Control</a>
+<li><code>TCIOFF</code>: <a href="#Line Control">Line Control</a>
+<li><code>TCIOFLUSH</code>: <a href="#Line Control">Line Control</a>
+<li><code>TCION</code>: <a href="#Line Control">Line Control</a>
+<li><code>TCOFLUSH</code>: <a href="#Line Control">Line Control</a>
+<li><code>TCOOFF</code>: <a href="#Line Control">Line Control</a>
+<li><code>TCOON</code>: <a href="#Line Control">Line Control</a>
+<li><code>TCSADRAIN</code>: <a href="#Mode Functions">Mode Functions</a>
+<li><code>TCSAFLUSH</code>: <a href="#Mode Functions">Mode Functions</a>
+<li><code>TCSANOW</code>: <a href="#Mode Functions">Mode Functions</a>
+<li><code>TCSASOFT</code>: <a href="#Mode Functions">Mode Functions</a>
+<li><code>THOUSANDS_SEP</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>THOUSEP</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>timezone</code>: <a href="#Time Zone Functions">Time Zone Functions</a>
+<li><code>TMP_MAX</code>: <a href="#Temporary Files">Temporary Files</a>
+<li><code>TOSTOP</code>: <a href="#Local Modes">Local Modes</a>
+<li><code>TRY_AGAIN</code>: <a href="#Host Names">Host Names</a>
+<li><code>tzname</code>: <a href="#Time Zone Functions">Time Zone Functions</a>
+<li><code>TZNAME_MAX</code>: <a href="#General Limits">General Limits</a>
+<li><code>UCHAR_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>UINT_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>ULONG_LONG_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>ULONG_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>USER_PROCESS</code>: <a href="#XPG Functions">XPG Functions</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>USHRT_MAX</code>: <a href="#Range of Type">Range of Type</a>
+<li><code>VDISCARD</code>: <a href="#Other Special">Other Special</a>
+<li><code>VDSUSP</code>: <a href="#Signal Characters">Signal Characters</a>
+<li><code>VEOF</code>: <a href="#Editing Characters">Editing Characters</a>
+<li><code>VEOL</code>: <a href="#Editing Characters">Editing Characters</a>
+<li><code>VEOL2</code>: <a href="#Editing Characters">Editing Characters</a>
+<li><code>VERASE</code>: <a href="#Editing Characters">Editing Characters</a>
+<li><code>VINTR</code>: <a href="#Signal Characters">Signal Characters</a>
+<li><code>VKILL</code>: <a href="#Editing Characters">Editing Characters</a>
+<li><code>VLNEXT</code>: <a href="#Other Special">Other Special</a>
+<li><code>VMIN</code>: <a href="#Noncanonical Input">Noncanonical Input</a>
+<li><code>VQUIT</code>: <a href="#Signal Characters">Signal Characters</a>
+<li><code>VREPRINT</code>: <a href="#Editing Characters">Editing Characters</a>
+<li><code>VSTART</code>: <a href="#Start%2fStop Characters">Start/Stop Characters</a>
+<li><code>VSTATUS</code>: <a href="#Other Special">Other Special</a>
+<li><code>VSTOP</code>: <a href="#Start%2fStop Characters">Start/Stop Characters</a>
+<li><code>VSUSP</code>: <a href="#Signal Characters">Signal Characters</a>
+<li><code>VTIME</code>: <a href="#Noncanonical Input">Noncanonical Input</a>
+<li><code>VWERASE</code>: <a href="#Editing Characters">Editing Characters</a>
+<li><code>W_OK</code>: <a href="#Testing File Access">Testing File Access</a>
+<li><code>WCHAR_MAX</code>: <a href="#Range of Type">Range of Type</a>, <a href="#Extended Char Intro">Extended Char Intro</a>
+<li><code>WCHAR_MIN</code>: <a href="#Extended Char Intro">Extended Char Intro</a>
+<li><code>WEOF</code>: <a href="#EOF and Errors">EOF and Errors</a>, <a href="#Extended Char Intro">Extended Char Intro</a>
+<li><code>X_OK</code>: <a href="#Testing File Access">Testing File Access</a>
+<li><code>YESEXPR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>YESSTR</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
 </ul>
 <p><hr>
-Node:<a name="File%20Index">File Index</a>,
-Previous:<a rel=previous accesskey=p href="#Variable%20Index">Variable Index</a>,
+Node:<a name="File Index">File Index</a>,
+Previous:<a rel=previous accesskey=p href="#Variable Index">Variable Index</a>,
 Up:<a rel=up accesskey=u href="#Top">Top</a>
 <br>
 
 <h2>Program and File Index</h2>
 
 <ul compact>
-<li><code>-lbsd-compat</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>, <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>/etc/group</code>: <a href="#Group%20Database">Group Database</a>
-<li><code>/etc/hosts</code>: <a href="#Host%20Names">Host Names</a>
-<li><code>/etc/localtime</code>: <a href="#TZ%20Variable">TZ Variable</a>
-<li><code>/etc/networks</code>: <a href="#Networks%20Database">Networks Database</a>
-<li><code>/etc/passwd</code>: <a href="#User%20Database">User Database</a>
-<li><code>/etc/protocols</code>: <a href="#Protocols%20Database">Protocols Database</a>
-<li><code>/etc/services</code>: <a href="#Services%20Database">Services Database</a>
-<li><code>/share/lib/zoneinfo</code>: <a href="#TZ%20Variable">TZ Variable</a>
+<li><code>-lbsd-compat</code>: <a href="#Process Group Functions">Process Group Functions</a>, <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>/etc/group</code>: <a href="#Group Database">Group Database</a>
+<li><code>/etc/hosts</code>: <a href="#Host Names">Host Names</a>
+<li><code>/etc/localtime</code>: <a href="#TZ Variable">TZ Variable</a>
+<li><code>/etc/networks</code>: <a href="#Networks Database">Networks Database</a>
+<li><code>/etc/passwd</code>: <a href="#User Database">User Database</a>
+<li><code>/etc/protocols</code>: <a href="#Protocols Database">Protocols Database</a>
+<li><code>/etc/services</code>: <a href="#Services Database">Services Database</a>
+<li><code>/share/lib/zoneinfo</code>: <a href="#TZ Variable">TZ Variable</a>
 <li><code>argp.h</code>: <a href="#Argp">Argp</a>
-<li><code>argz.h</code>: <a href="#Argz%20Functions">Argz Functions</a>
-<li><code>arpa/inet.h</code>: <a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><code>assert.h</code>: <a href="#Consistency%20Checking">Consistency Checking</a>
-<li><code>bsd-compat</code>: <a href="#Process%20Group%20Functions">Process Group Functions</a>, <a href="#Feature%20Test%20Macros">Feature Test Macros</a>
-<li><code>cd</code>: <a href="#Working%20Directory">Working Directory</a>
-<li><code>chgrp</code>: <a href="#File%20Owner">File Owner</a>
-<li><code>chown</code>: <a href="#File%20Owner">File Owner</a>
-<li><code>complex.h</code>: <a href="#Operations%20on%20Complex">Operations on Complex</a>, <a href="#Complex%20Numbers">Complex Numbers</a>, <a href="#Mathematics">Mathematics</a>
-<li><code>ctype.h</code>: <a href="#Case%20Conversion">Case Conversion</a>, <a href="#Classification%20of%20Characters">Classification of Characters</a>, <a href="#Character%20Handling">Character Handling</a>
-<li><code>dirent.h</code>: <a href="#Random%20Access%20Directory">Random Access Directory</a>, <a href="#Reading%2fClosing%20Directory">Reading/Closing Directory</a>, <a href="#Opening%20a%20Directory">Opening a Directory</a>, <a href="#Directory%20Entries">Directory Entries</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>envz.h</code>: <a href="#Envz%20Functions">Envz Functions</a>
-<li><code>errno.h</code>: <a href="#Error%20Codes">Error Codes</a>, <a href="#Checking%20for%20Errors">Checking for Errors</a>, <a href="#Error%20Reporting">Error Reporting</a>
+<li><code>argz.h</code>: <a href="#Argz Functions">Argz Functions</a>
+<li><code>arpa/inet.h</code>: <a href="#Host Address Functions">Host Address Functions</a>
+<li><code>assert.h</code>: <a href="#Consistency Checking">Consistency Checking</a>
+<li><code>bsd-compat</code>: <a href="#Process Group Functions">Process Group Functions</a>, <a href="#Feature Test Macros">Feature Test Macros</a>
+<li><code>cd</code>: <a href="#Working Directory">Working Directory</a>
+<li><code>chgrp</code>: <a href="#File Owner">File Owner</a>
+<li><code>chown</code>: <a href="#File Owner">File Owner</a>
+<li><code>complex.h</code>: <a href="#Operations on Complex">Operations on Complex</a>, <a href="#Complex Numbers">Complex Numbers</a>, <a href="#Mathematics">Mathematics</a>
+<li><code>ctype.h</code>: <a href="#Case Conversion">Case Conversion</a>, <a href="#Classification of Characters">Classification of Characters</a>, <a href="#Character Handling">Character Handling</a>
+<li><code>dirent.h</code>: <a href="#Random Access Directory">Random Access Directory</a>, <a href="#Reading%2fClosing Directory">Reading/Closing Directory</a>, <a href="#Opening a Directory">Opening a Directory</a>, <a href="#Directory Entries">Directory Entries</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>envz.h</code>: <a href="#Envz Functions">Envz Functions</a>
+<li><code>errno.h</code>: <a href="#Error Codes">Error Codes</a>, <a href="#Checking for Errors">Checking for Errors</a>, <a href="#Error Reporting">Error Reporting</a>
 <li><code>execinfo.h</code>: <a href="#Backtraces">Backtraces</a>
-<li><code>fcntl.h</code>: <a href="#Interrupt%20Input">Interrupt Input</a>, <a href="#File%20Locks">File Locks</a>, <a href="#File%20Status%20Flags">File Status Flags</a>, <a href="#Descriptor%20Flags">Descriptor Flags</a>, <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>, <a href="#Control%20Operations">Control Operations</a>, <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>float.h</code>: <a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><code>fnmatch.h</code>: <a href="#Wildcard%20Matching">Wildcard Matching</a>
-<li><code>gcc</code>: <a href="#ISO%20C">ISO C</a>
-<li><code>gconv.h</code>: <a href="#glibc%20iconv%20Implementation">glibc iconv Implementation</a>
-<li><code>grp.h</code>: <a href="#Group%20Data%20Structure">Group Data Structure</a>, <a href="#Setting%20Groups">Setting Groups</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>hostid</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>hostname</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>iconv.h</code>: <a href="#Generic%20Conversion%20Interface">Generic Conversion Interface</a>
-<li><code>kill</code>: <a href="#Termination%20Signals">Termination Signals</a>
-<li><code>ksh</code>: <a href="#Wildcard%20Matching">Wildcard Matching</a>
-<li><code>langinfo.h</code>: <a href="#The%20Elegant%20and%20Fast%20Way">The Elegant and Fast Way</a>
-<li><code>limits.h</code>: <a href="#Width%20of%20Type">Width of Type</a>, <a href="#Limits%20for%20Files">Limits for Files</a>, <a href="#General%20Limits">General Limits</a>, <a href="#Selecting%20the%20Conversion">Selecting the Conversion</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>locale</code>: <a href="#Setting%20the%20Locale">Setting the Locale</a>
-<li><code>locale.h</code>: <a href="#The%20Lame%20Way%20to%20Locale%20Data">The Lame Way to Locale Data</a>, <a href="#Setting%20the%20Locale">Setting the Locale</a>
-<li><code>localtime</code>: <a href="#TZ%20Variable">TZ Variable</a>
-<li><code>ls</code>: <a href="#File%20Attributes">File Attributes</a>
-<li><code>malloc.h</code>: <a href="#Statistics%20of%20Malloc">Statistics of Malloc</a>, <a href="#Hooks%20for%20Malloc">Hooks for Malloc</a>, <a href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>
-<li><code>math.h</code>: <a href="#Rounding%20Functions">Rounding Functions</a>, <a href="#Normalization%20Functions">Normalization Functions</a>, <a href="#Absolute%20Value">Absolute Value</a>, <a href="#Floating%20Point%20Classes">Floating Point Classes</a>, <a href="#Mathematics">Mathematics</a>
-<li><code>mcheck.h</code>: <a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>
-<li><code>mkdir</code>: <a href="#Creating%20Directories">Creating Directories</a>
-<li><code>netdb.h</code>: <a href="#Networks%20Database">Networks Database</a>, <a href="#Protocols%20Database">Protocols Database</a>, <a href="#Services%20Database">Services Database</a>, <a href="#Host%20Names">Host Names</a>
-<li><code>netinet/in.h</code>: <a href="#Byte%20Order">Byte Order</a>, <a href="#Ports">Ports</a>, <a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>, <a href="#Internet%20Address%20Formats">Internet Address Formats</a>
-<li><code>obstack.h</code>: <a href="#Creating%20Obstacks">Creating Obstacks</a>
-<li><code>printf.h</code>: <a href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>, <a href="#Registering%20New%20Conversions">Registering New Conversions</a>
-<li><code>pwd.h</code>: <a href="#User%20Data%20Structure">User Data Structure</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>setjmp.h</code>: <a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>, <a href="#Non-Local%20Details">Non-Local Details</a>
-<li><code>sh</code>: <a href="#Running%20a%20Command">Running a Command</a>
-<li><code>signal.h</code>: <a href="#BSD%20Signal%20Handling">BSD Signal Handling</a>, <a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>, <a href="#Process%20Signal%20Mask">Process Signal Mask</a>, <a href="#Signal%20Sets">Signal Sets</a>, <a href="#Signaling%20Another%20Process">Signaling Another Process</a>, <a href="#Signaling%20Yourself">Signaling Yourself</a>, <a href="#Flags%20for%20Sigaction">Flags for Sigaction</a>, <a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>, <a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>, <a href="#Standard%20Signals">Standard Signals</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>stdarg.h</code>: <a href="#Argument%20Macros">Argument Macros</a>, <a href="#Receiving%20Arguments">Receiving Arguments</a>
-<li><code>stddef.h</code>: <a href="#Important%20Data%20Types">Important Data Types</a>
+<li><code>fcntl.h</code>: <a href="#Interrupt Input">Interrupt Input</a>, <a href="#File Locks">File Locks</a>, <a href="#File Status Flags">File Status Flags</a>, <a href="#Descriptor Flags">Descriptor Flags</a>, <a href="#Duplicating Descriptors">Duplicating Descriptors</a>, <a href="#Control Operations">Control Operations</a>, <a href="#Opening and Closing Files">Opening and Closing Files</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>float.h</code>: <a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><code>fnmatch.h</code>: <a href="#Wildcard Matching">Wildcard Matching</a>
+<li><code>gcc</code>: <a href="#ISO C">ISO C</a>
+<li><code>gconv.h</code>: <a href="#glibc iconv Implementation">glibc iconv Implementation</a>
+<li><code>grp.h</code>: <a href="#Group Data Structure">Group Data Structure</a>, <a href="#Setting Groups">Setting Groups</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>hostid</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>hostname</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>iconv.h</code>: <a href="#Generic Conversion Interface">Generic Conversion Interface</a>
+<li><code>kill</code>: <a href="#Termination Signals">Termination Signals</a>
+<li><code>ksh</code>: <a href="#Wildcard Matching">Wildcard Matching</a>
+<li><code>langinfo.h</code>: <a href="#The Elegant and Fast Way">The Elegant and Fast Way</a>
+<li><code>limits.h</code>: <a href="#Width of Type">Width of Type</a>, <a href="#Limits for Files">Limits for Files</a>, <a href="#General Limits">General Limits</a>, <a href="#Selecting the Conversion">Selecting the Conversion</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>locale</code>: <a href="#Setting the Locale">Setting the Locale</a>
+<li><code>locale.h</code>: <a href="#The Lame Way to Locale Data">The Lame Way to Locale Data</a>, <a href="#Setting the Locale">Setting the Locale</a>
+<li><code>localtime</code>: <a href="#TZ Variable">TZ Variable</a>
+<li><code>ls</code>: <a href="#File Attributes">File Attributes</a>
+<li><code>malloc.h</code>: <a href="#Statistics of Malloc">Statistics of Malloc</a>, <a href="#Hooks for Malloc">Hooks for Malloc</a>, <a href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>
+<li><code>math.h</code>: <a href="#Rounding Functions">Rounding Functions</a>, <a href="#Normalization Functions">Normalization Functions</a>, <a href="#Absolute Value">Absolute Value</a>, <a href="#Floating Point Classes">Floating Point Classes</a>, <a href="#Mathematics">Mathematics</a>
+<li><code>mcheck.h</code>: <a href="#Heap Consistency Checking">Heap Consistency Checking</a>
+<li><code>mkdir</code>: <a href="#Creating Directories">Creating Directories</a>
+<li><code>netdb.h</code>: <a href="#Networks Database">Networks Database</a>, <a href="#Protocols Database">Protocols Database</a>, <a href="#Services Database">Services Database</a>, <a href="#Host Names">Host Names</a>
+<li><code>netinet/in.h</code>: <a href="#Byte Order">Byte Order</a>, <a href="#Ports">Ports</a>, <a href="#Host Address Data Type">Host Address Data Type</a>, <a href="#Internet Address Formats">Internet Address Formats</a>
+<li><code>obstack.h</code>: <a href="#Creating Obstacks">Creating Obstacks</a>
+<li><code>printf.h</code>: <a href="#Conversion Specifier Options">Conversion Specifier Options</a>, <a href="#Registering New Conversions">Registering New Conversions</a>
+<li><code>pwd.h</code>: <a href="#User Data Structure">User Data Structure</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>setjmp.h</code>: <a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>, <a href="#Non-Local Details">Non-Local Details</a>
+<li><code>sh</code>: <a href="#Running a Command">Running a Command</a>
+<li><code>signal.h</code>: <a href="#BSD Signal Handling">BSD Signal Handling</a>, <a href="#Checking for Pending Signals">Checking for Pending Signals</a>, <a href="#Process Signal Mask">Process Signal Mask</a>, <a href="#Signal Sets">Signal Sets</a>, <a href="#Signaling Another Process">Signaling Another Process</a>, <a href="#Signaling Yourself">Signaling Yourself</a>, <a href="#Flags for Sigaction">Flags for Sigaction</a>, <a href="#Advanced Signal Handling">Advanced Signal Handling</a>, <a href="#Basic Signal Handling">Basic Signal Handling</a>, <a href="#Standard Signals">Standard Signals</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>stdarg.h</code>: <a href="#Argument Macros">Argument Macros</a>, <a href="#Receiving Arguments">Receiving Arguments</a>
+<li><code>stddef.h</code>: <a href="#Important Data Types">Important Data Types</a>
 <li><code>stdint.h</code>: <a href="#Integers">Integers</a>
-<li><code>stdio.h</code>: <a href="#Who%20Logged%20In">Who Logged In</a>, <a href="#Identifying%20the%20Terminal">Identifying the Terminal</a>, <a href="#Signal%20Messages">Signal Messages</a>, <a href="#Temporary%20Files">Temporary Files</a>, <a href="#Deleting%20Files">Deleting Files</a>, <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>, <a href="#Streams%20and%20Cookies">Streams and Cookies</a>, <a href="#String%20Streams">String Streams</a>, <a href="#Controlling%20Buffering">Controlling Buffering</a>, <a href="#Flushing%20Buffers">Flushing Buffers</a>, <a href="#Portable%20Positioning">Portable Positioning</a>, <a href="#File%20Positioning">File Positioning</a>, <a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>, <a href="#Variable%20Arguments%20Output">Variable Arguments Output</a>, <a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>, <a href="#Block%20Input%2fOutput">Block Input/Output</a>, <a href="#Character%20Input">Character Input</a>, <a href="#Simple%20Output">Simple Output</a>, <a href="#Opening%20Streams">Opening Streams</a>, <a href="#Standard%20Streams">Standard Streams</a>, <a href="#Streams">Streams</a>
-<li><code>stdlib.h</code>: <a href="#Running%20a%20Command">Running a Command</a>, <a href="#Aborting%20a%20Program">Aborting a Program</a>, <a href="#Exit%20Status">Exit Status</a>, <a href="#Environment%20Access">Environment Access</a>, <a href="#Parsing%20of%20Floats">Parsing of Floats</a>, <a href="#Parsing%20of%20Integers">Parsing of Integers</a>, <a href="#Absolute%20Value">Absolute Value</a>, <a href="#Integer%20Division">Integer Division</a>, <a href="#SVID%20Random">SVID Random</a>, <a href="#BSD%20Random">BSD Random</a>, <a href="#ISO%20Random">ISO Random</a>, <a href="#Allocation">Allocation</a>, <a href="#Array%20Sort%20Function">Array Sort Function</a>, <a href="#Array%20Search%20Function">Array Search Function</a>, <a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Character Conversion</a>, <a href="#Selecting%20the%20Conversion">Selecting the Conversion</a>, <a href="#Variable%20Size%20Automatic">Variable Size Automatic</a>, <a href="#Aligned%20Memory%20Blocks">Aligned Memory Blocks</a>, <a href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>, <a href="#Changing%20Block%20Size">Changing Block Size</a>, <a href="#Freeing%20after%20Malloc">Freeing after Malloc</a>, <a href="#Basic%20Allocation">Basic Allocation</a>
-<li><code>string.h</code>: <a href="#Signal%20Messages">Signal Messages</a>, <a href="#Trivial%20Encryption">Trivial Encryption</a>, <a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>, <a href="#Search%20Functions">Search Functions</a>, <a href="#Collation%20Functions">Collation Functions</a>, <a href="#String%2fArray%20Comparison">String/Array Comparison</a>, <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>, <a href="#String%20Length">String Length</a>
-<li><code>sys/param.h</code>: <a href="#Host%20Identification">Host Identification</a>
-<li><code>sys/resource.h</code>: <a href="#Traditional%20Scheduling%20Functions">Traditional Scheduling Functions</a>, <a href="#Limits%20on%20Resources">Limits on Resources</a>, <a href="#Resource%20Usage">Resource Usage</a>
-<li><code>sys/socket.h</code>: <a href="#Socket-Level%20Options">Socket-Level Options</a>, <a href="#Socket%20Option%20Functions">Socket Option Functions</a>, <a href="#Sending%20Datagrams">Sending Datagrams</a>, <a href="#Socket%20Data%20Options">Socket Data Options</a>, <a href="#Receiving%20Data">Receiving Data</a>, <a href="#Sending%20Data">Sending Data</a>, <a href="#Socket%20Pairs">Socket Pairs</a>, <a href="#Closing%20a%20Socket">Closing a Socket</a>, <a href="#Creating%20a%20Socket">Creating a Socket</a>, <a href="#Internet%20Namespace">Internet Namespace</a>, <a href="#Local%20Namespace%20Details">Local Namespace Details</a>, <a href="#Reading%20Address">Reading Address</a>, <a href="#Setting%20Address">Setting Address</a>, <a href="#Address%20Formats">Address Formats</a>, <a href="#Communication%20Styles">Communication Styles</a>
-<li><code>sys/stat.h</code>: <a href="#FIFO%20Special%20Files">FIFO Special Files</a>, <a href="#Making%20Special%20Files">Making Special Files</a>, <a href="#Setting%20Permissions">Setting Permissions</a>, <a href="#Permission%20Bits">Permission Bits</a>, <a href="#Testing%20File%20Type">Testing File Type</a>, <a href="#Attribute%20Meanings">Attribute Meanings</a>, <a href="#Creating%20Directories">Creating Directories</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>sys/time.h</code>: <a href="#Setting%20an%20Alarm">Setting an Alarm</a>, <a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>, <a href="#File%20Times">File Times</a>
-<li><code>sys/times.h</code>: <a href="#Processor%20Time">Processor Time</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>sys/timex.h</code>: <a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li><code>sys/types.h</code>: <a href="#Setting%20Groups">Setting Groups</a>, <a href="#Setting%20User%20ID">Setting User ID</a>, <a href="#Reading%20Persona">Reading Persona</a>, <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>, <a href="#Process%20Group%20Functions">Process Group Functions</a>, <a href="#Process%20Identification">Process Identification</a>, <a href="#Waiting%20for%20I%2fO">Waiting for I/O</a>
-<li><code>sys/un.h</code>: <a href="#Local%20Namespace%20Details">Local Namespace Details</a>
-<li><code>sys/utsname.h</code>: <a href="#Platform%20Type">Platform Type</a>
-<li><code>sys/vlimit.h</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>sys/vtimes.h</code>: <a href="#Resource%20Usage">Resource Usage</a>
-<li><code>sys/wait.h</code>: <a href="#BSD%20Wait%20Functions">BSD Wait Functions</a>, <a href="#Process%20Completion%20Status">Process Completion Status</a>, <a href="#Process%20Completion">Process Completion</a>
-<li><code>termios.h</code>: <a href="#Terminal%20Modes">Terminal Modes</a>, <a href="#Reserved%20Names">Reserved Names</a>
-<li><code>time.h</code>: <a href="#TZ%20Variable">TZ Variable</a>, <a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>, <a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>, <a href="#CPU%20Time">CPU Time</a>, <a href="#File%20Times">File Times</a>
-<li><code>ulimit.h</code>: <a href="#Limits%20on%20Resources">Limits on Resources</a>
-<li><code>umask</code>: <a href="#Setting%20Permissions">Setting Permissions</a>
-<li><code>unistd.h</code>: <a href="#Options%20for%20Files">Options for Files</a>, <a href="#System%20Options">System Options</a>, <a href="#Host%20Identification">Host Identification</a>, <a href="#Who%20Logged%20In">Who Logged In</a>, <a href="#Setting%20Groups">Setting Groups</a>, <a href="#Setting%20User%20ID">Setting User ID</a>, <a href="#Reading%20Persona">Reading Persona</a>, <a href="#Terminal%20Access%20Functions">Terminal Access Functions</a>, <a href="#Process%20Group%20Functions">Process Group Functions</a>, <a href="#Executing%20a%20File">Executing a File</a>, <a href="#Creating%20a%20Process">Creating a Process</a>, <a href="#Process%20Identification">Process Identification</a>, <a href="#Termination%20Internals">Termination Internals</a>, <a href="#Using%20Getopt">Using Getopt</a>, <a href="#Setting%20an%20Alarm">Setting an Alarm</a>, <a href="#Is%20It%20a%20Terminal">Is It a Terminal</a>, <a href="#Creating%20a%20Pipe">Creating a Pipe</a>, <a href="#Testing%20File%20Access">Testing File Access</a>, <a href="#File%20Owner">File Owner</a>, <a href="#Deleting%20Files">Deleting Files</a>, <a href="#Symbolic%20Links">Symbolic Links</a>, <a href="#Hard%20Links">Hard Links</a>, <a href="#Working%20Directory">Working Directory</a>, <a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>, <a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>, <a href="#I%2fO%20Primitives">I/O Primitives</a>, <a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li><code>utime.h</code>: <a href="#File%20Times">File Times</a>
-<li><code>utmp.h</code>: <a href="#Logging%20In%20and%20Out">Logging In and Out</a>, <a href="#Manipulating%20the%20Database">Manipulating the Database</a>
-<li><code>utmpx.h</code>: <a href="#XPG%20Functions">XPG Functions</a>
-<li><code>varargs.h</code>: <a href="#Old%20Varargs">Old Varargs</a>
-<li><code>wchar.h</code>: <a href="#Parsing%20of%20Integers">Parsing of Integers</a>, <a href="#Character%20Input">Character Input</a>, <a href="#Simple%20Output">Simple Output</a>, <a href="#Converting%20Strings">Converting Strings</a>, <a href="#Converting%20a%20Character">Converting a Character</a>, <a href="#Keeping%20the%20state">Keeping the state</a>, <a href="#Extended%20Char%20Intro">Extended Char Intro</a>, <a href="#Collation%20Functions">Collation Functions</a>, <a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><code>wctype.h</code>: <a href="#Wide%20Character%20Case%20Conversion">Wide Character Case Conversion</a>, <a href="#Classification%20of%20Wide%20Characters">Classification of Wide Characters</a>
-<li><code>zoneinfo</code>: <a href="#TZ%20Variable">TZ Variable</a>
+<li><code>stdio.h</code>: <a href="#Who Logged In">Who Logged In</a>, <a href="#Identifying the Terminal">Identifying the Terminal</a>, <a href="#Signal Messages">Signal Messages</a>, <a href="#Temporary Files">Temporary Files</a>, <a href="#Deleting Files">Deleting Files</a>, <a href="#Descriptors and Streams">Descriptors and Streams</a>, <a href="#Streams and Cookies">Streams and Cookies</a>, <a href="#String Streams">String Streams</a>, <a href="#Controlling Buffering">Controlling Buffering</a>, <a href="#Flushing Buffers">Flushing Buffers</a>, <a href="#Portable Positioning">Portable Positioning</a>, <a href="#File Positioning">File Positioning</a>, <a href="#Formatted Input Functions">Formatted Input Functions</a>, <a href="#Variable Arguments Output">Variable Arguments Output</a>, <a href="#Formatted Output Functions">Formatted Output Functions</a>, <a href="#Block Input%2fOutput">Block Input/Output</a>, <a href="#Character Input">Character Input</a>, <a href="#Simple Output">Simple Output</a>, <a href="#Opening Streams">Opening Streams</a>, <a href="#Standard Streams">Standard Streams</a>, <a href="#Streams">Streams</a>
+<li><code>stdlib.h</code>: <a href="#Running a Command">Running a Command</a>, <a href="#Aborting a Program">Aborting a Program</a>, <a href="#Exit Status">Exit Status</a>, <a href="#Environment Access">Environment Access</a>, <a href="#Parsing of Floats">Parsing of Floats</a>, <a href="#Parsing of Integers">Parsing of Integers</a>, <a href="#Absolute Value">Absolute Value</a>, <a href="#Integer Division">Integer Division</a>, <a href="#SVID Random">SVID Random</a>, <a href="#BSD Random">BSD Random</a>, <a href="#ISO Random">ISO Random</a>, <a href="#Allocation">Allocation</a>, <a href="#Array Sort Function">Array Sort Function</a>, <a href="#Array Search Function">Array Search Function</a>, <a href="#Non-reentrant Character Conversion">Non-reentrant Character Conversion</a>, <a href="#Selecting the Conversion">Selecting the Conversion</a>, <a href="#Variable Size Automatic">Variable Size Automatic</a>, <a href="#Aligned Memory Blocks">Aligned Memory Blocks</a>, <a href="#Allocating Cleared Space">Allocating Cleared Space</a>, <a href="#Changing Block Size">Changing Block Size</a>, <a href="#Freeing after Malloc">Freeing after Malloc</a>, <a href="#Basic Allocation">Basic Allocation</a>
+<li><code>string.h</code>: <a href="#Signal Messages">Signal Messages</a>, <a href="#Trivial Encryption">Trivial Encryption</a>, <a href="#Finding Tokens in a String">Finding Tokens in a String</a>, <a href="#Search Functions">Search Functions</a>, <a href="#Collation Functions">Collation Functions</a>, <a href="#String%2fArray Comparison">String/Array Comparison</a>, <a href="#Copying and Concatenation">Copying and Concatenation</a>, <a href="#String Length">String Length</a>
+<li><code>sys/param.h</code>: <a href="#Host Identification">Host Identification</a>
+<li><code>sys/resource.h</code>: <a href="#Traditional Scheduling Functions">Traditional Scheduling Functions</a>, <a href="#Limits on Resources">Limits on Resources</a>, <a href="#Resource Usage">Resource Usage</a>
+<li><code>sys/socket.h</code>: <a href="#Socket-Level Options">Socket-Level Options</a>, <a href="#Socket Option Functions">Socket Option Functions</a>, <a href="#Sending Datagrams">Sending Datagrams</a>, <a href="#Socket Data Options">Socket Data Options</a>, <a href="#Receiving Data">Receiving Data</a>, <a href="#Sending Data">Sending Data</a>, <a href="#Socket Pairs">Socket Pairs</a>, <a href="#Closing a Socket">Closing a Socket</a>, <a href="#Creating a Socket">Creating a Socket</a>, <a href="#Internet Namespace">Internet Namespace</a>, <a href="#Local Namespace Details">Local Namespace Details</a>, <a href="#Reading Address">Reading Address</a>, <a href="#Setting Address">Setting Address</a>, <a href="#Address Formats">Address Formats</a>, <a href="#Communication Styles">Communication Styles</a>
+<li><code>sys/stat.h</code>: <a href="#FIFO Special Files">FIFO Special Files</a>, <a href="#Making Special Files">Making Special Files</a>, <a href="#Setting Permissions">Setting Permissions</a>, <a href="#Permission Bits">Permission Bits</a>, <a href="#Testing File Type">Testing File Type</a>, <a href="#Attribute Meanings">Attribute Meanings</a>, <a href="#Creating Directories">Creating Directories</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>sys/time.h</code>: <a href="#Setting an Alarm">Setting an Alarm</a>, <a href="#High-Resolution Calendar">High-Resolution Calendar</a>, <a href="#File Times">File Times</a>
+<li><code>sys/times.h</code>: <a href="#Processor Time">Processor Time</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>sys/timex.h</code>: <a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li><code>sys/types.h</code>: <a href="#Setting Groups">Setting Groups</a>, <a href="#Setting User ID">Setting User ID</a>, <a href="#Reading Persona">Reading Persona</a>, <a href="#Terminal Access Functions">Terminal Access Functions</a>, <a href="#Process Group Functions">Process Group Functions</a>, <a href="#Process Identification">Process Identification</a>, <a href="#Waiting for I%2fO">Waiting for I/O</a>
+<li><code>sys/un.h</code>: <a href="#Local Namespace Details">Local Namespace Details</a>
+<li><code>sys/utsname.h</code>: <a href="#Platform Type">Platform Type</a>
+<li><code>sys/vlimit.h</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>sys/vtimes.h</code>: <a href="#Resource Usage">Resource Usage</a>
+<li><code>sys/wait.h</code>: <a href="#BSD Wait Functions">BSD Wait Functions</a>, <a href="#Process Completion Status">Process Completion Status</a>, <a href="#Process Completion">Process Completion</a>
+<li><code>termios.h</code>: <a href="#Terminal Modes">Terminal Modes</a>, <a href="#Reserved Names">Reserved Names</a>
+<li><code>time.h</code>: <a href="#TZ Variable">TZ Variable</a>, <a href="#Formatting Calendar Time">Formatting Calendar Time</a>, <a href="#Simple Calendar Time">Simple Calendar Time</a>, <a href="#CPU Time">CPU Time</a>, <a href="#File Times">File Times</a>
+<li><code>ulimit.h</code>: <a href="#Limits on Resources">Limits on Resources</a>
+<li><code>umask</code>: <a href="#Setting Permissions">Setting Permissions</a>
+<li><code>unistd.h</code>: <a href="#Options for Files">Options for Files</a>, <a href="#System Options">System Options</a>, <a href="#Host Identification">Host Identification</a>, <a href="#Who Logged In">Who Logged In</a>, <a href="#Setting Groups">Setting Groups</a>, <a href="#Setting User ID">Setting User ID</a>, <a href="#Reading Persona">Reading Persona</a>, <a href="#Terminal Access Functions">Terminal Access Functions</a>, <a href="#Process Group Functions">Process Group Functions</a>, <a href="#Executing a File">Executing a File</a>, <a href="#Creating a Process">Creating a Process</a>, <a href="#Process Identification">Process Identification</a>, <a href="#Termination Internals">Termination Internals</a>, <a href="#Using Getopt">Using Getopt</a>, <a href="#Setting an Alarm">Setting an Alarm</a>, <a href="#Is It a Terminal">Is It a Terminal</a>, <a href="#Creating a Pipe">Creating a Pipe</a>, <a href="#Testing File Access">Testing File Access</a>, <a href="#File Owner">File Owner</a>, <a href="#Deleting Files">Deleting Files</a>, <a href="#Symbolic Links">Symbolic Links</a>, <a href="#Hard Links">Hard Links</a>, <a href="#Working Directory">Working Directory</a>, <a href="#Duplicating Descriptors">Duplicating Descriptors</a>, <a href="#Descriptors and Streams">Descriptors and Streams</a>, <a href="#I%2fO Primitives">I/O Primitives</a>, <a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li><code>utime.h</code>: <a href="#File Times">File Times</a>
+<li><code>utmp.h</code>: <a href="#Logging In and Out">Logging In and Out</a>, <a href="#Manipulating the Database">Manipulating the Database</a>
+<li><code>utmpx.h</code>: <a href="#XPG Functions">XPG Functions</a>
+<li><code>varargs.h</code>: <a href="#Old Varargs">Old Varargs</a>
+<li><code>wchar.h</code>: <a href="#Parsing of Integers">Parsing of Integers</a>, <a href="#Character Input">Character Input</a>, <a href="#Simple Output">Simple Output</a>, <a href="#Converting Strings">Converting Strings</a>, <a href="#Converting a Character">Converting a Character</a>, <a href="#Keeping the state">Keeping the state</a>, <a href="#Extended Char Intro">Extended Char Intro</a>, <a href="#Collation Functions">Collation Functions</a>, <a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><code>wctype.h</code>: <a href="#Wide Character Case Conversion">Wide Character Case Conversion</a>, <a href="#Classification of Wide Characters">Classification of Wide Characters</a>
+<li><code>zoneinfo</code>: <a href="#TZ Variable">TZ Variable</a>
 </ul>
 
 
 <h2>Short Contents</h2>
 <ul>
 <li><a href="#toc_Top">Main Menu</a>
 <li><a href="#toc_Introduction">Introduction</a>
-<li><a href="#toc_Error%20Reporting">Error Reporting</a>
+<li><a href="#toc_Error Reporting">Error Reporting</a>
 <li><a href="#toc_Memory">Virtual Memory Allocation And Paging</a>
-<li><a href="#toc_Character%20Handling">Character Handling</a>
-<li><a href="#toc_String%20and%20Array%20Utilities">String and Array Utilities</a>
-<li><a href="#toc_Character%20Set%20Handling">Character Set Handling</a>
+<li><a href="#toc_Character Handling">Character Handling</a>
+<li><a href="#toc_String and Array Utilities">String and Array Utilities</a>
+<li><a href="#toc_Character Set Handling">Character Set Handling</a>
 <li><a href="#toc_Locales">Locales and Internationalization</a>
-<li><a href="#toc_Message%20Translation">Message Translation</a>
-<li><a href="#toc_Searching%20and%20Sorting">Searching and Sorting</a>
-<li><a href="#toc_Pattern%20Matching">Pattern Matching</a>
-<li><a href="#toc_I%2fO%20Overview">Input/Output Overview</a>
-<li><a href="#toc_I%2fO%20on%20Streams">Input/Output on Streams</a>
-<li><a href="#toc_Low-Level%20I%2fO">Low-Level Input/Output</a>
-<li><a href="#toc_File%20System%20Interface">File System Interface</a>
-<li><a href="#toc_Pipes%20and%20FIFOs">Pipes and FIFOs</a>
+<li><a href="#toc_Message Translation">Message Translation</a>
+<li><a href="#toc_Searching and Sorting">Searching and Sorting</a>
+<li><a href="#toc_Pattern Matching">Pattern Matching</a>
+<li><a href="#toc_I%2fO Overview">Input/Output Overview</a>
+<li><a href="#toc_I%2fO on Streams">Input/Output on Streams</a>
+<li><a href="#toc_Low-Level I%2fO">Low-Level Input/Output</a>
+<li><a href="#toc_File System Interface">File System Interface</a>
+<li><a href="#toc_Pipes and FIFOs">Pipes and FIFOs</a>
 <li><a href="#toc_Sockets">Sockets</a>
-<li><a href="#toc_Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
+<li><a href="#toc_Low-Level Terminal Interface">Low-Level Terminal Interface</a>
 <li><a href="#toc_Syslog">Syslog</a>
 <li><a href="#toc_Mathematics">Mathematics</a>
 <li><a href="#toc_Arithmetic">Arithmetic Functions</a>
-<li><a href="#toc_Date%20and%20Time">Date and Time</a>
-<li><a href="#toc_Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>
-<li><a href="#toc_Non-Local%20Exits">Non-Local Exits</a>
-<li><a href="#toc_Signal%20Handling">Signal Handling</a>
-<li><a href="#toc_Program%20Basics">The Basic Program/System Interface</a>
+<li><a href="#toc_Date and Time">Date and Time</a>
+<li><a href="#toc_Resource Usage And Limitation">Resource Usage And Limitation</a>
+<li><a href="#toc_Non-Local Exits">Non-Local Exits</a>
+<li><a href="#toc_Signal Handling">Signal Handling</a>
+<li><a href="#toc_Program Basics">The Basic Program/System Interface</a>
 <li><a href="#toc_Processes">Processes</a>
-<li><a href="#toc_Job%20Control">Job Control</a>
-<li><a href="#toc_Name%20Service%20Switch">System Databases and Name Service Switch</a>
-<li><a href="#toc_Users%20and%20Groups">Users and Groups</a>
-<li><a href="#toc_System%20Management">System Management</a>
-<li><a href="#toc_System%20Configuration">System Configuration Parameters</a>
-<li><a href="#toc_Cryptographic%20Functions">DES Encryption and Password Handling</a>
-<li><a href="#toc_Debugging%20Support">Debugging support</a>
-<li><a href="#toc_Language%20Features">C Language Facilities in the Library</a>
-<li><a href="#toc_Library%20Summary">Summary of Library Facilities</a>
+<li><a href="#toc_Job Control">Job Control</a>
+<li><a href="#toc_Name Service Switch">System Databases and Name Service Switch</a>
+<li><a href="#toc_Users and Groups">Users and Groups</a>
+<li><a href="#toc_System Management">System Management</a>
+<li><a href="#toc_System Configuration">System Configuration Parameters</a>
+<li><a href="#toc_Cryptographic Functions">DES Encryption and Password Handling</a>
+<li><a href="#toc_Debugging Support">Debugging support</a>
+<li><a href="#toc_Language Features">C Language Facilities in the Library</a>
+<li><a href="#toc_Library Summary">Summary of Library Facilities</a>
 <li><a href="#toc_Installation">Installing the GNU C Library</a>
 <li><a href="#toc_Maintenance">Library Maintenance</a>
 <li><a href="#toc_Contributors">Contributors to the GNU C Library</a>
-<li><a href="#toc_Free%20Manuals">Free Software Needs Free Documentation</a>
+<li><a href="#toc_Free Manuals">Free Software Needs Free Documentation</a>
 <li><a href="#toc_Copying">GNU Lesser General Public License</a>
-<li><a href="#toc_Documentation%20License">GNU Free Documentation License</a>
-<li><a href="#toc_Concept%20Index">Concept Index</a>
-<li><a href="#toc_Type%20Index">Type Index</a>
-<li><a href="#toc_Function%20Index">Function and Macro Index</a>
-<li><a href="#toc_Variable%20Index">Variable and Constant Macro Index</a>
-<li><a href="#toc_File%20Index">Program and File Index</a>
+<li><a href="#toc_Documentation License">GNU Free Documentation License</a>
+<li><a href="#toc_Concept Index">Concept Index</a>
+<li><a href="#toc_Type Index">Type Index</a>
+<li><a href="#toc_Function Index">Function and Macro Index</a>
+<li><a href="#toc_Variable Index">Variable and Constant Macro Index</a>
+<li><a href="#toc_File Index">Program and File Index</a>
 </ul>
 
 
 <h2>Table of Contents</h2>
@@ -91870,1045 +90261,1045 @@
     <a href="#Top">Main Menu</a>
 <li><a name="toc_Introduction"></a>
     <a href="#Introduction">Introduction</a>
 <ul>
-<li><a href="#Getting%20Started">Getting Started</a>
-<li><a href="#Standards%20and%20Portability">Standards and Portability</a>
+<li><a href="#Getting Started">Getting Started</a>
+<li><a href="#Standards and Portability">Standards and Portability</a>
 <ul>
-<li><a href="#ISO%20C">ISO C</a>
+<li><a href="#ISO C">ISO C</a>
 <li><a href="#POSIX">POSIX (The Portable Operating System Interface)</a>
-<li><a href="#Berkeley%20Unix">Berkeley Unix</a>
+<li><a href="#Berkeley Unix">Berkeley Unix</a>
 <li><a href="#SVID">SVID (The System V Interface Description)</a>
 <li><a href="#XPG">XPG (The X/Open Portability Guide)</a>
 </ul>
-<li><a href="#Using%20the%20Library">Using the Library</a>
+<li><a href="#Using the Library">Using the Library</a>
 <ul>
-<li><a href="#Header%20Files">Header Files</a>
-<li><a href="#Macro%20Definitions">Macro Definitions of Functions</a>
-<li><a href="#Reserved%20Names">Reserved Names</a>
-<li><a href="#Feature%20Test%20Macros">Feature Test Macros</a>
+<li><a href="#Header Files">Header Files</a>
+<li><a href="#Macro Definitions">Macro Definitions of Functions</a>
+<li><a href="#Reserved Names">Reserved Names</a>
+<li><a href="#Feature Test Macros">Feature Test Macros</a>
 </ul>
-<li><a href="#Roadmap%20to%20the%20Manual">Roadmap to the Manual</a>
+<li><a href="#Roadmap to the Manual">Roadmap to the Manual</a>
 </ul>
-<li><a name="toc_Error%20Reporting"></a>
-    <a href="#Error%20Reporting">Error Reporting</a>
+<li><a name="toc_Error Reporting"></a>
+    <a href="#Error Reporting">Error Reporting</a>
 <ul>
-<li><a href="#Checking%20for%20Errors">Checking for Errors</a>
-<li><a href="#Error%20Codes">Error Codes</a>
-<li><a href="#Error%20Messages">Error Messages</a>
+<li><a href="#Checking for Errors">Checking for Errors</a>
+<li><a href="#Error Codes">Error Codes</a>
+<li><a href="#Error Messages">Error Messages</a>
 </ul>
 <li><a name="toc_Memory"></a>
     <a href="#Memory">Virtual Memory Allocation And Paging</a>
 <ul>
-<li><a href="#Memory%20Concepts">Process Memory Concepts</a>
-<li><a href="#Memory%20Allocation">Allocating Storage For Program Data</a>
+<li><a href="#Memory Concepts">Process Memory Concepts</a>
+<li><a href="#Memory Allocation">Allocating Storage For Program Data</a>
 <ul>
-<li><a href="#Memory%20Allocation%20and%20C">Memory Allocation in C Programs</a>
+<li><a href="#Memory Allocation and C">Memory Allocation in C Programs</a>
 <ul>
-<li><a href="#Memory%20Allocation%20and%20C">Dynamic Memory Allocation</a>
+<li><a href="#Memory Allocation and C">Dynamic Memory Allocation</a>
 </ul>
-<li><a href="#Unconstrained%20Allocation">Unconstrained Allocation</a>
+<li><a href="#Unconstrained Allocation">Unconstrained Allocation</a>
 <ul>
-<li><a href="#Basic%20Allocation">Basic Memory Allocation</a>
-<li><a href="#Malloc%20Examples">Examples of <code>malloc</code></a>
-<li><a href="#Freeing%20after%20Malloc">Freeing Memory Allocated with <code>malloc</code></a>
-<li><a href="#Changing%20Block%20Size">Changing the Size of a Block</a>
-<li><a href="#Allocating%20Cleared%20Space">Allocating Cleared Space</a>
-<li><a href="#Efficiency%20and%20Malloc">Efficiency Considerations for <code>malloc</code></a>
-<li><a href="#Aligned%20Memory%20Blocks">Allocating Aligned Memory Blocks</a>
-<li><a href="#Malloc%20Tunable%20Parameters">Malloc Tunable Parameters</a>
-<li><a href="#Heap%20Consistency%20Checking">Heap Consistency Checking</a>
-<li><a href="#Hooks%20for%20Malloc">Memory Allocation Hooks</a>
-<li><a href="#Statistics%20of%20Malloc">Statistics for Memory Allocation with <code>malloc</code></a>
-<li><a href="#Summary%20of%20Malloc">Summary of <code>malloc</code>-Related Functions</a>
-</ul>
-<li><a href="#Allocation%20Debugging">Allocation Debugging</a>
-<ul>
-<li><a href="#Tracing%20malloc">How to install the tracing functionality</a>
-<li><a href="#Using%20the%20Memory%20Debugger">Example program excerpts</a>
-<li><a href="#Tips%20for%20the%20Memory%20Debugger">Some more or less clever ideas</a>
-<li><a href="#Interpreting%20the%20traces">Interpreting the traces</a>
+<li><a href="#Basic Allocation">Basic Memory Allocation</a>
+<li><a href="#Malloc Examples">Examples of <code>malloc</code></a>
+<li><a href="#Freeing after Malloc">Freeing Memory Allocated with <code>malloc</code></a>
+<li><a href="#Changing Block Size">Changing the Size of a Block</a>
+<li><a href="#Allocating Cleared Space">Allocating Cleared Space</a>
+<li><a href="#Efficiency and Malloc">Efficiency Considerations for <code>malloc</code></a>
+<li><a href="#Aligned Memory Blocks">Allocating Aligned Memory Blocks</a>
+<li><a href="#Malloc Tunable Parameters">Malloc Tunable Parameters</a>
+<li><a href="#Heap Consistency Checking">Heap Consistency Checking</a>
+<li><a href="#Hooks for Malloc">Memory Allocation Hooks</a>
+<li><a href="#Statistics of Malloc">Statistics for Memory Allocation with <code>malloc</code></a>
+<li><a href="#Summary of Malloc">Summary of <code>malloc</code>-Related Functions</a>
+</ul>
+<li><a href="#Allocation Debugging">Allocation Debugging</a>
+<ul>
+<li><a href="#Tracing malloc">How to install the tracing functionality</a>
+<li><a href="#Using the Memory Debugger">Example program excerpts</a>
+<li><a href="#Tips for the Memory Debugger">Some more or less clever ideas</a>
+<li><a href="#Interpreting the traces">Interpreting the traces</a>
 </ul>
 <li><a href="#Obstacks">Obstacks</a>
 <ul>
-<li><a href="#Creating%20Obstacks">Creating Obstacks</a>
-<li><a href="#Preparing%20for%20Obstacks">Preparing for Using Obstacks</a>
-<li><a href="#Allocation%20in%20an%20Obstack">Allocation in an Obstack</a>
-<li><a href="#Freeing%20Obstack%20Objects">Freeing Objects in an Obstack</a>
-<li><a href="#Obstack%20Functions">Obstack Functions and Macros</a>
-<li><a href="#Growing%20Objects">Growing Objects</a>
-<li><a href="#Extra%20Fast%20Growing">Extra Fast Growing Objects</a>
-<li><a href="#Status%20of%20an%20Obstack">Status of an Obstack</a>
-<li><a href="#Obstacks%20Data%20Alignment">Alignment of Data in Obstacks</a>
-<li><a href="#Obstack%20Chunks">Obstack Chunks</a>
-<li><a href="#Summary%20of%20Obstacks">Summary of Obstack Functions</a>
-</ul>
-<li><a href="#Variable%20Size%20Automatic">Automatic Storage with Variable Size</a>
-<ul>
-<li><a href="#Alloca%20Example"><code>alloca</code> Example</a>
-<li><a href="#Advantages%20of%20Alloca">Advantages of <code>alloca</code></a>
-<li><a href="#Disadvantages%20of%20Alloca">Disadvantages of <code>alloca</code></a>
-<li><a href="#GNU%20C%20Variable-Size%20Arrays">GNU C Variable-Size Arrays</a>
-</ul>
-</ul>
-<li><a href="#Resizing%20the%20Data%20Segment">Resizing the Data Segment</a>
-<li><a href="#Locking%20Pages">Locking Pages</a>
-<ul>
-<li><a href="#Why%20Lock%20Pages">Why Lock Pages</a>
-<li><a href="#Locked%20Memory%20Details">Locked Memory Details</a>
-<li><a href="#Page%20Lock%20Functions">Functions To Lock And Unlock Pages</a>
-</ul>
-</ul>
-<li><a name="toc_Character%20Handling"></a>
-    <a href="#Character%20Handling">Character Handling</a>
-<ul>
-<li><a href="#Classification%20of%20Characters">Classification of Characters</a>
-<li><a href="#Case%20Conversion">Case Conversion</a>
-<li><a href="#Classification%20of%20Wide%20Characters">Character class determination for wide characters</a>
-<li><a href="#Using%20Wide%20Char%20Classes">Notes on using the wide character classes</a>
-<li><a href="#Wide%20Character%20Case%20Conversion">Mapping of wide characters.</a>
-</ul>
-<li><a name="toc_String%20and%20Array%20Utilities"></a>
-    <a href="#String%20and%20Array%20Utilities">String and Array Utilities</a>
-<ul>
-<li><a href="#Representation%20of%20Strings">Representation of Strings</a>
-<li><a href="#String%2fArray%20Conventions">String and Array Conventions</a>
-<li><a href="#String%20Length">String Length</a>
-<li><a href="#Copying%20and%20Concatenation">Copying and Concatenation</a>
-<li><a href="#String%2fArray%20Comparison">String/Array Comparison</a>
-<li><a href="#Collation%20Functions">Collation Functions</a>
-<li><a href="#Search%20Functions">Search Functions</a>
+<li><a href="#Creating Obstacks">Creating Obstacks</a>
+<li><a href="#Preparing for Obstacks">Preparing for Using Obstacks</a>
+<li><a href="#Allocation in an Obstack">Allocation in an Obstack</a>
+<li><a href="#Freeing Obstack Objects">Freeing Objects in an Obstack</a>
+<li><a href="#Obstack Functions">Obstack Functions and Macros</a>
+<li><a href="#Growing Objects">Growing Objects</a>
+<li><a href="#Extra Fast Growing">Extra Fast Growing Objects</a>
+<li><a href="#Status of an Obstack">Status of an Obstack</a>
+<li><a href="#Obstacks Data Alignment">Alignment of Data in Obstacks</a>
+<li><a href="#Obstack Chunks">Obstack Chunks</a>
+<li><a href="#Summary of Obstacks">Summary of Obstack Functions</a>
+</ul>
+<li><a href="#Variable Size Automatic">Automatic Storage with Variable Size</a>
+<ul>
+<li><a href="#Alloca Example"><code>alloca</code> Example</a>
+<li><a href="#Advantages of Alloca">Advantages of <code>alloca</code></a>
+<li><a href="#Disadvantages of Alloca">Disadvantages of <code>alloca</code></a>
+<li><a href="#GNU C Variable-Size Arrays">GNU C Variable-Size Arrays</a>
+</ul>
+</ul>
+<li><a href="#Resizing the Data Segment">Resizing the Data Segment</a>
+<li><a href="#Locking Pages">Locking Pages</a>
+<ul>
+<li><a href="#Why Lock Pages">Why Lock Pages</a>
+<li><a href="#Locked Memory Details">Locked Memory Details</a>
+<li><a href="#Page Lock Functions">Functions To Lock And Unlock Pages</a>
+</ul>
+</ul>
+<li><a name="toc_Character Handling"></a>
+    <a href="#Character Handling">Character Handling</a>
+<ul>
+<li><a href="#Classification of Characters">Classification of Characters</a>
+<li><a href="#Case Conversion">Case Conversion</a>
+<li><a href="#Classification of Wide Characters">Character class determination for wide characters</a>
+<li><a href="#Using Wide Char Classes">Notes on using the wide character classes</a>
+<li><a href="#Wide Character Case Conversion">Mapping of wide characters.</a>
+</ul>
+<li><a name="toc_String and Array Utilities"></a>
+    <a href="#String and Array Utilities">String and Array Utilities</a>
+<ul>
+<li><a href="#Representation of Strings">Representation of Strings</a>
+<li><a href="#String%2fArray Conventions">String and Array Conventions</a>
+<li><a href="#String Length">String Length</a>
+<li><a href="#Copying and Concatenation">Copying and Concatenation</a>
+<li><a href="#String%2fArray Comparison">String/Array Comparison</a>
+<li><a href="#Collation Functions">Collation Functions</a>
+<li><a href="#Search Functions">Search Functions</a>
 <ul>
-<li><a href="#Search%20Functions">Compatibility String Search Functions</a>
+<li><a href="#Search Functions">Compatibility String Search Functions</a>
 </ul>
-<li><a href="#Finding%20Tokens%20in%20a%20String">Finding Tokens in a String</a>
+<li><a href="#Finding Tokens in a String">Finding Tokens in a String</a>
 <li><a href="#strfry">strfry</a>
-<li><a href="#Trivial%20Encryption">Trivial Encryption</a>
-<li><a href="#Encode%20Binary%20Data">Encode Binary Data</a>
-<li><a href="#Argz%20and%20Envz%20Vectors">Argz and Envz Vectors</a>
+<li><a href="#Trivial Encryption">Trivial Encryption</a>
+<li><a href="#Encode Binary Data">Encode Binary Data</a>
+<li><a href="#Argz and Envz Vectors">Argz and Envz Vectors</a>
 <ul>
-<li><a href="#Argz%20Functions">Argz Functions</a>
-<li><a href="#Envz%20Functions">Envz Functions</a>
+<li><a href="#Argz Functions">Argz Functions</a>
+<li><a href="#Envz Functions">Envz Functions</a>
 </ul>
 </ul>
-<li><a name="toc_Character%20Set%20Handling"></a>
-    <a href="#Character%20Set%20Handling">Character Set Handling</a>
+<li><a name="toc_Character Set Handling"></a>
+    <a href="#Character Set Handling">Character Set Handling</a>
 <ul>
-<li><a href="#Extended%20Char%20Intro">Introduction to Extended Characters</a>
-<li><a href="#Charset%20Function%20Overview">Overview about Character Handling Functions</a>
-<li><a href="#Restartable%20multibyte%20conversion">Restartable Multibyte Conversion Functions</a>
+<li><a href="#Extended Char Intro">Introduction to Extended Characters</a>
+<li><a href="#Charset Function Overview">Overview about Character Handling Functions</a>
+<li><a href="#Restartable multibyte conversion">Restartable Multibyte Conversion Functions</a>
 <ul>
-<li><a href="#Selecting%20the%20Conversion">Selecting the conversion and its properties</a>
-<li><a href="#Keeping%20the%20state">Representing the state of the conversion</a>
-<li><a href="#Converting%20a%20Character">Converting Single Characters</a>
-<li><a href="#Converting%20Strings">Converting Multibyte and Wide Character Strings</a>
-<li><a href="#Multibyte%20Conversion%20Example">A Complete Multibyte Conversion Example</a>
+<li><a href="#Selecting the Conversion">Selecting the conversion and its properties</a>
+<li><a href="#Keeping the state">Representing the state of the conversion</a>
+<li><a href="#Converting a Character">Converting Single Characters</a>
+<li><a href="#Converting Strings">Converting Multibyte and Wide Character Strings</a>
+<li><a href="#Multibyte Conversion Example">A Complete Multibyte Conversion Example</a>
 </ul>
-<li><a href="#Non-reentrant%20Conversion">Non-reentrant Conversion Function</a>
+<li><a href="#Non-reentrant Conversion">Non-reentrant Conversion Function</a>
 <ul>
-<li><a href="#Non-reentrant%20Character%20Conversion">Non-reentrant Conversion of Single Characters</a>
-<li><a href="#Non-reentrant%20String%20Conversion">Non-reentrant Conversion of Strings</a>
-<li><a href="#Shift%20State">States in Non-reentrant Functions</a>
+<li><a href="#Non-reentrant Character Conversion">Non-reentrant Conversion of Single Characters</a>
+<li><a href="#Non-reentrant String Conversion">Non-reentrant Conversion of Strings</a>
+<li><a href="#Shift State">States in Non-reentrant Functions</a>
 </ul>
-<li><a href="#Generic%20Charset%20Conversion">Generic Charset Conversion</a>
+<li><a href="#Generic Charset Conversion">Generic Charset Conversion</a>
 <ul>
-<li><a href="#Generic%20Conversion%20Interface">Generic Character Set Conversion Interface</a>
-<li><a href="#iconv%20Examples">A complete <code>iconv</code> example</a>
-<li><a href="#Other%20iconv%20Implementations">Some Details about other <code>iconv</code> Implementations</a>
-<li><a href="#glibc%20iconv%20Implementation">The <code>iconv</code> Implementation in the GNU C library</a>
+<li><a href="#Generic Conversion Interface">Generic Character Set Conversion Interface</a>
+<li><a href="#iconv Examples">A complete <code>iconv</code> example</a>
+<li><a href="#Other iconv Implementations">Some Details about other <code>iconv</code> Implementations</a>
+<li><a href="#glibc iconv Implementation">The <code>iconv</code> Implementation in the GNU C library</a>
 <ul>
-<li><a href="#glibc%20iconv%20Implementation">Format of <code>gconv-modules</code> files</a>
-<li><a href="#glibc%20iconv%20Implementation">Finding the conversion path in <code>iconv</code></a>
-<li><a href="#glibc%20iconv%20Implementation"><code>iconv</code> module data structures</a>
-<li><a href="#glibc%20iconv%20Implementation"><code>iconv</code> module interfaces</a>
+<li><a href="#glibc iconv Implementation">Format of <code>gconv-modules</code> files</a>
+<li><a href="#glibc iconv Implementation">Finding the conversion path in <code>iconv</code></a>
+<li><a href="#glibc iconv Implementation"><code>iconv</code> module data structures</a>
+<li><a href="#glibc iconv Implementation"><code>iconv</code> module interfaces</a>
 </ul>
 </ul>
 </ul>
 <li><a name="toc_Locales"></a>
     <a href="#Locales">Locales and Internationalization</a>
 <ul>
-<li><a href="#Effects%20of%20Locale">What Effects a Locale Has</a>
-<li><a href="#Choosing%20Locale">Choosing a Locale</a>
-<li><a href="#Locale%20Categories">Categories of Activities that Locales Affect</a>
-<li><a href="#Setting%20the%20Locale">How Programs Set the Locale</a>
-<li><a href="#Standard%20Locales">Standard Locales</a>
-<li><a href="#Locale%20Information">Accessing Locale Information</a>
+<li><a href="#Effects of Locale">What Effects a Locale Has</a>
+<li><a href="#Choosing Locale">Choosing a Locale</a>
+<li><a href="#Locale Categories">Categories of Activities that Locales Affect</a>
+<li><a href="#Setting the Locale">How Programs Set the Locale</a>
+<li><a href="#Standard Locales">Standard Locales</a>
+<li><a href="#Locale Information">Accessing Locale Information</a>
 <ul>
-<li><a href="#The%20Lame%20Way%20to%20Locale%20Data"><code>localeconv</code>: It is portable but <small>...</small></a>
+<li><a href="#The Lame Way to Locale Data"><code>localeconv</code>: It is portable but <small>...</small></a>
 <ul>
-<li><a href="#General%20Numeric">Generic Numeric Formatting Parameters</a>
-<li><a href="#Currency%20Symbol">Printing the Currency Symbol</a>
-<li><a href="#Sign%20of%20Money%20Amount">Printing the Sign of a Monetary Amount</a>
+<li><a href="#General Numeric">Generic Numeric Formatting Parameters</a>
+<li><a href="#Currency Symbol">Printing the Currency Symbol</a>
+<li><a href="#Sign of Money Amount">Printing the Sign of a Monetary Amount</a>
 </ul>
-<li><a href="#The%20Elegant%20and%20Fast%20Way">Pinpoint Access to Locale Data</a>
+<li><a href="#The Elegant and Fast Way">Pinpoint Access to Locale Data</a>
 </ul>
-<li><a href="#Formatting%20Numbers">A dedicated function to format numbers</a>
-<li><a href="#Yes-or-No%20Questions">Yes-or-No Questions</a>
+<li><a href="#Formatting Numbers">A dedicated function to format numbers</a>
+<li><a href="#Yes-or-No Questions">Yes-or-No Questions</a>
 </ul>
-<li><a name="toc_Message%20Translation"></a>
-    <a href="#Message%20Translation">Message Translation</a>
+<li><a name="toc_Message Translation"></a>
+    <a href="#Message Translation">Message Translation</a>
 <ul>
-<li><a href="#Message%20catalogs%20a%20la%20X%2fOpen">X/Open Message Catalog Handling</a>
+<li><a href="#Message catalogs a la X%2fOpen">X/Open Message Catalog Handling</a>
 <ul>
-<li><a href="#The%20catgets%20Functions">The <code>catgets</code> function family</a>
-<li><a href="#The%20message%20catalog%20files">Format of the message catalog files</a>
-<li><a href="#The%20gencat%20program">Generate Message Catalogs files</a>
-<li><a href="#Common%20Usage">How to use the <code>catgets</code> interface</a>
+<li><a href="#The catgets Functions">The <code>catgets</code> function family</a>
+<li><a href="#The message catalog files">Format of the message catalog files</a>
+<li><a href="#The gencat program">Generate Message Catalogs files</a>
+<li><a href="#Common Usage">How to use the <code>catgets</code> interface</a>
 <ul>
-<li><a href="#Common%20Usage">Not using symbolic names</a>
-<li><a href="#Common%20Usage">Using symbolic names</a>
-<li><a href="#Common%20Usage">How does to this allow to develop</a>
+<li><a href="#Common Usage">Not using symbolic names</a>
+<li><a href="#Common Usage">Using symbolic names</a>
+<li><a href="#Common Usage">How does to this allow to develop</a>
 </ul>
 </ul>
-<li><a href="#The%20Uniforum%20approach">The Uniforum approach to Message Translation</a>
+<li><a href="#The Uniforum approach">The Uniforum approach to Message Translation</a>
 <ul>
-<li><a href="#Message%20catalogs%20with%20gettext">The <code>gettext</code> family of functions</a>
+<li><a href="#Message catalogs with gettext">The <code>gettext</code> family of functions</a>
 <ul>
-<li><a href="#Translation%20with%20gettext">What has to be done to translate a message?</a>
-<li><a href="#Locating%20gettext%20catalog">How to determine which catalog to be used</a>
-<li><a href="#Advanced%20gettext%20functions">Additional functions for more complicated situations</a>
-<li><a href="#Charset%20conversion%20in%20gettext">How to specify the output character set <code>gettext</code> uses</a>
-<li><a href="#GUI%20program%20problems">How to use <code>gettext</code> in GUI programs</a>
-<li><a href="#Using%20gettextized%20software">User influence on <code>gettext</code></a>
+<li><a href="#Translation with gettext">What has to be done to translate a message?</a>
+<li><a href="#Locating gettext catalog">How to determine which catalog to be used</a>
+<li><a href="#Advanced gettext functions">Additional functions for more complicated situations</a>
+<li><a href="#Charset conversion in gettext">How to specify the output character set <code>gettext</code> uses</a>
+<li><a href="#GUI program problems">How to use <code>gettext</code> in GUI programs</a>
+<li><a href="#Using gettextized software">User influence on <code>gettext</code></a>
 </ul>
-<li><a href="#Helper%20programs%20for%20gettext">Programs to handle message catalogs for <code>gettext</code></a>
+<li><a href="#Helper programs for gettext">Programs to handle message catalogs for <code>gettext</code></a>
 </ul>
 </ul>
-<li><a name="toc_Searching%20and%20Sorting"></a>
-    <a href="#Searching%20and%20Sorting">Searching and Sorting</a>
+<li><a name="toc_Searching and Sorting"></a>
+    <a href="#Searching and Sorting">Searching and Sorting</a>
 <ul>
-<li><a href="#Comparison%20Functions">Defining the Comparison Function</a>
-<li><a href="#Array%20Search%20Function">Array Search Function</a>
-<li><a href="#Array%20Sort%20Function">Array Sort Function</a>
-<li><a href="#Search%2fSort%20Example">Searching and Sorting Example</a>
-<li><a href="#Hash%20Search%20Function">The <code>hsearch</code> function.</a>
-<li><a href="#Tree%20Search%20Function">The <code>tsearch</code> function.</a>
+<li><a href="#Comparison Functions">Defining the Comparison Function</a>
+<li><a href="#Array Search Function">Array Search Function</a>
+<li><a href="#Array Sort Function">Array Sort Function</a>
+<li><a href="#Search%2fSort Example">Searching and Sorting Example</a>
+<li><a href="#Hash Search Function">The <code>hsearch</code> function.</a>
+<li><a href="#Tree Search Function">The <code>tsearch</code> function.</a>
 </ul>
-<li><a name="toc_Pattern%20Matching"></a>
-    <a href="#Pattern%20Matching">Pattern Matching</a>
+<li><a name="toc_Pattern Matching"></a>
+    <a href="#Pattern Matching">Pattern Matching</a>
 <ul>
-<li><a href="#Wildcard%20Matching">Wildcard Matching</a>
+<li><a href="#Wildcard Matching">Wildcard Matching</a>
 <li><a href="#Globbing">Globbing</a>
 <ul>
-<li><a href="#Calling%20Glob">Calling <code>glob</code></a>
-<li><a href="#Flags%20for%20Globbing">Flags for Globbing</a>
-<li><a href="#More%20Flags%20for%20Globbing">More Flags for Globbing</a>
+<li><a href="#Calling Glob">Calling <code>glob</code></a>
+<li><a href="#Flags for Globbing">Flags for Globbing</a>
+<li><a href="#More Flags for Globbing">More Flags for Globbing</a>
 </ul>
-<li><a href="#Regular%20Expressions">Regular Expression Matching</a>
+<li><a href="#Regular Expressions">Regular Expression Matching</a>
 <ul>
-<li><a href="#POSIX%20Regexp%20Compilation">POSIX Regular Expression Compilation</a>
-<li><a href="#Flags%20for%20POSIX%20Regexps">Flags for POSIX Regular Expressions</a>
-<li><a href="#Matching%20POSIX%20Regexps">Matching a Compiled POSIX Regular Expression</a>
-<li><a href="#Regexp%20Subexpressions">Match Results with Subexpressions</a>
-<li><a href="#Subexpression%20Complications">Complications in Subexpression Matching</a>
-<li><a href="#Regexp%20Cleanup">POSIX Regexp Matching Cleanup</a>
+<li><a href="#POSIX Regexp Compilation">POSIX Regular Expression Compilation</a>
+<li><a href="#Flags for POSIX Regexps">Flags for POSIX Regular Expressions</a>
+<li><a href="#Matching POSIX Regexps">Matching a Compiled POSIX Regular Expression</a>
+<li><a href="#Regexp Subexpressions">Match Results with Subexpressions</a>
+<li><a href="#Subexpression Complications">Complications in Subexpression Matching</a>
+<li><a href="#Regexp Cleanup">POSIX Regexp Matching Cleanup</a>
 </ul>
-<li><a href="#Word%20Expansion">Shell-Style Word Expansion</a>
+<li><a href="#Word Expansion">Shell-Style Word Expansion</a>
 <ul>
-<li><a href="#Expansion%20Stages">The Stages of Word Expansion</a>
-<li><a href="#Calling%20Wordexp">Calling <code>wordexp</code></a>
-<li><a href="#Flags%20for%20Wordexp">Flags for Word Expansion</a>
-<li><a href="#Wordexp%20Example"><code>wordexp</code> Example</a>
-<li><a href="#Tilde%20Expansion">Details of Tilde Expansion</a>
-<li><a href="#Variable%20Substitution">Details of Variable Substitution</a>
+<li><a href="#Expansion Stages">The Stages of Word Expansion</a>
+<li><a href="#Calling Wordexp">Calling <code>wordexp</code></a>
+<li><a href="#Flags for Wordexp">Flags for Word Expansion</a>
+<li><a href="#Wordexp Example"><code>wordexp</code> Example</a>
+<li><a href="#Tilde Expansion">Details of Tilde Expansion</a>
+<li><a href="#Variable Substitution">Details of Variable Substitution</a>
 </ul>
 </ul>
-<li><a name="toc_I%2fO%20Overview"></a>
-    <a href="#I%2fO%20Overview">Input/Output Overview</a>
+<li><a name="toc_I%2fO Overview"></a>
+    <a href="#I%2fO Overview">Input/Output Overview</a>
 <ul>
-<li><a href="#I%2fO%20Concepts">Input/Output Concepts</a>
+<li><a href="#I%2fO Concepts">Input/Output Concepts</a>
 <ul>
-<li><a href="#Streams%20and%20File%20Descriptors">Streams and File Descriptors</a>
-<li><a href="#File%20Position">File Position</a>
+<li><a href="#Streams and File Descriptors">Streams and File Descriptors</a>
+<li><a href="#File Position">File Position</a>
 </ul>
-<li><a href="#File%20Names">File Names</a>
+<li><a href="#File Names">File Names</a>
 <ul>
 <li><a href="#Directories">Directories</a>
-<li><a href="#File%20Name%20Resolution">File Name Resolution</a>
-<li><a href="#File%20Name%20Errors">File Name Errors</a>
-<li><a href="#File%20Name%20Portability">Portability of File Names</a>
+<li><a href="#File Name Resolution">File Name Resolution</a>
+<li><a href="#File Name Errors">File Name Errors</a>
+<li><a href="#File Name Portability">Portability of File Names</a>
 </ul>
 </ul>
-<li><a name="toc_I%2fO%20on%20Streams"></a>
-    <a href="#I%2fO%20on%20Streams">Input/Output on Streams</a>
+<li><a name="toc_I%2fO on Streams"></a>
+    <a href="#I%2fO on Streams">Input/Output on Streams</a>
 <ul>
 <li><a href="#Streams">Streams</a>
-<li><a href="#Standard%20Streams">Standard Streams</a>
-<li><a href="#Opening%20Streams">Opening Streams</a>
-<li><a href="#Closing%20Streams">Closing Streams</a>
-<li><a href="#Streams%20and%20Threads">Streams and Threads</a>
-<li><a href="#Streams%20and%20I18N">Streams in Internationalized Applications</a>
-<li><a href="#Simple%20Output">Simple Output by Characters or Lines</a>
-<li><a href="#Character%20Input">Character Input</a>
-<li><a href="#Line%20Input">Line-Oriented Input</a>
+<li><a href="#Standard Streams">Standard Streams</a>
+<li><a href="#Opening Streams">Opening Streams</a>
+<li><a href="#Closing Streams">Closing Streams</a>
+<li><a href="#Streams and Threads">Streams and Threads</a>
+<li><a href="#Streams and I18N">Streams in Internationalized Applications</a>
+<li><a href="#Simple Output">Simple Output by Characters or Lines</a>
+<li><a href="#Character Input">Character Input</a>
+<li><a href="#Line Input">Line-Oriented Input</a>
 <li><a href="#Unreading">Unreading</a>
 <ul>
-<li><a href="#Unreading%20Idea">What Unreading Means</a>
-<li><a href="#How%20Unread">Using <code>ungetc</code> To Do Unreading</a>
+<li><a href="#Unreading Idea">What Unreading Means</a>
+<li><a href="#How Unread">Using <code>ungetc</code> To Do Unreading</a>
 </ul>
-<li><a href="#Block%20Input%2fOutput">Block Input/Output</a>
-<li><a href="#Formatted%20Output">Formatted Output</a>
+<li><a href="#Block Input%2fOutput">Block Input/Output</a>
+<li><a href="#Formatted Output">Formatted Output</a>
 <ul>
-<li><a href="#Formatted%20Output%20Basics">Formatted Output Basics</a>
-<li><a href="#Output%20Conversion%20Syntax">Output Conversion Syntax</a>
-<li><a href="#Table%20of%20Output%20Conversions">Table of Output Conversions</a>
-<li><a href="#Integer%20Conversions">Integer Conversions</a>
-<li><a href="#Floating-Point%20Conversions">Floating-Point Conversions</a>
-<li><a href="#Other%20Output%20Conversions">Other Output Conversions</a>
-<li><a href="#Formatted%20Output%20Functions">Formatted Output Functions</a>
-<li><a href="#Dynamic%20Output">Dynamically Allocating Formatted Output</a>
-<li><a href="#Variable%20Arguments%20Output">Variable Arguments Output Functions</a>
-<li><a href="#Parsing%20a%20Template%20String">Parsing a Template String</a>
-<li><a href="#Example%20of%20Parsing">Example of Parsing a Template String</a>
-</ul>
-<li><a href="#Customizing%20Printf">Customizing <code>printf</code></a>
-<ul>
-<li><a href="#Registering%20New%20Conversions">Registering New Conversions</a>
-<li><a href="#Conversion%20Specifier%20Options">Conversion Specifier Options</a>
-<li><a href="#Defining%20the%20Output%20Handler">Defining the Output Handler</a>
-<li><a href="#Printf%20Extension%20Example"><code>printf</code> Extension Example</a>
-<li><a href="#Predefined%20Printf%20Handlers">Predefined <code>printf</code> Handlers</a>
-</ul>
-<li><a href="#Formatted%20Input">Formatted Input</a>
-<ul>
-<li><a href="#Formatted%20Input%20Basics">Formatted Input Basics</a>
-<li><a href="#Input%20Conversion%20Syntax">Input Conversion Syntax</a>
-<li><a href="#Table%20of%20Input%20Conversions">Table of Input Conversions</a>
-<li><a href="#Numeric%20Input%20Conversions">Numeric Input Conversions</a>
-<li><a href="#String%20Input%20Conversions">String Input Conversions</a>
-<li><a href="#Dynamic%20String%20Input">Dynamically Allocating String Conversions</a>
-<li><a href="#Other%20Input%20Conversions">Other Input Conversions</a>
-<li><a href="#Formatted%20Input%20Functions">Formatted Input Functions</a>
-<li><a href="#Variable%20Arguments%20Input">Variable Arguments Input Functions</a>
-</ul>
-<li><a href="#EOF%20and%20Errors">End-Of-File and Errors</a>
-<li><a href="#Error%20Recovery">Recovering from errors</a>
-<li><a href="#Binary%20Streams">Text and Binary Streams</a>
-<li><a href="#File%20Positioning">File Positioning</a>
-<li><a href="#Portable%20Positioning">Portable File-Position Functions</a>
-<li><a href="#Stream%20Buffering">Stream Buffering</a>
-<ul>
-<li><a href="#Buffering%20Concepts">Buffering Concepts</a>
-<li><a href="#Flushing%20Buffers">Flushing Buffers</a>
-<li><a href="#Controlling%20Buffering">Controlling Which Kind of Buffering</a>
-</ul>
-<li><a href="#Other%20Kinds%20of%20Streams">Other Kinds of Streams</a>
-<ul>
-<li><a href="#String%20Streams">String Streams</a>
-<li><a href="#Obstack%20Streams">Obstack Streams</a>
-<li><a href="#Custom%20Streams">Programming Your Own Custom Streams</a>
+<li><a href="#Formatted Output Basics">Formatted Output Basics</a>
+<li><a href="#Output Conversion Syntax">Output Conversion Syntax</a>
+<li><a href="#Table of Output Conversions">Table of Output Conversions</a>
+<li><a href="#Integer Conversions">Integer Conversions</a>
+<li><a href="#Floating-Point Conversions">Floating-Point Conversions</a>
+<li><a href="#Other Output Conversions">Other Output Conversions</a>
+<li><a href="#Formatted Output Functions">Formatted Output Functions</a>
+<li><a href="#Dynamic Output">Dynamically Allocating Formatted Output</a>
+<li><a href="#Variable Arguments Output">Variable Arguments Output Functions</a>
+<li><a href="#Parsing a Template String">Parsing a Template String</a>
+<li><a href="#Example of Parsing">Example of Parsing a Template String</a>
+</ul>
+<li><a href="#Customizing Printf">Customizing <code>printf</code></a>
+<ul>
+<li><a href="#Registering New Conversions">Registering New Conversions</a>
+<li><a href="#Conversion Specifier Options">Conversion Specifier Options</a>
+<li><a href="#Defining the Output Handler">Defining the Output Handler</a>
+<li><a href="#Printf Extension Example"><code>printf</code> Extension Example</a>
+<li><a href="#Predefined Printf Handlers">Predefined <code>printf</code> Handlers</a>
+</ul>
+<li><a href="#Formatted Input">Formatted Input</a>
+<ul>
+<li><a href="#Formatted Input Basics">Formatted Input Basics</a>
+<li><a href="#Input Conversion Syntax">Input Conversion Syntax</a>
+<li><a href="#Table of Input Conversions">Table of Input Conversions</a>
+<li><a href="#Numeric Input Conversions">Numeric Input Conversions</a>
+<li><a href="#String Input Conversions">String Input Conversions</a>
+<li><a href="#Dynamic String Input">Dynamically Allocating String Conversions</a>
+<li><a href="#Other Input Conversions">Other Input Conversions</a>
+<li><a href="#Formatted Input Functions">Formatted Input Functions</a>
+<li><a href="#Variable Arguments Input">Variable Arguments Input Functions</a>
+</ul>
+<li><a href="#EOF and Errors">End-Of-File and Errors</a>
+<li><a href="#Error Recovery">Recovering from errors</a>
+<li><a href="#Binary Streams">Text and Binary Streams</a>
+<li><a href="#File Positioning">File Positioning</a>
+<li><a href="#Portable Positioning">Portable File-Position Functions</a>
+<li><a href="#Stream Buffering">Stream Buffering</a>
+<ul>
+<li><a href="#Buffering Concepts">Buffering Concepts</a>
+<li><a href="#Flushing Buffers">Flushing Buffers</a>
+<li><a href="#Controlling Buffering">Controlling Which Kind of Buffering</a>
+</ul>
+<li><a href="#Other Kinds of Streams">Other Kinds of Streams</a>
+<ul>
+<li><a href="#String Streams">String Streams</a>
+<li><a href="#Obstack Streams">Obstack Streams</a>
+<li><a href="#Custom Streams">Programming Your Own Custom Streams</a>
 <ul>
-<li><a href="#Streams%20and%20Cookies">Custom Streams and Cookies</a>
-<li><a href="#Hook%20Functions">Custom Stream Hook Functions</a>
+<li><a href="#Streams and Cookies">Custom Streams and Cookies</a>
+<li><a href="#Hook Functions">Custom Stream Hook Functions</a>
 </ul>
 </ul>
-<li><a href="#Formatted%20Messages">Formatted Messages</a>
+<li><a href="#Formatted Messages">Formatted Messages</a>
 <ul>
-<li><a href="#Printing%20Formatted%20Messages">Printing Formatted Messages</a>
-<li><a href="#Adding%20Severity%20Classes">Adding Severity Classes</a>
+<li><a href="#Printing Formatted Messages">Printing Formatted Messages</a>
+<li><a href="#Adding Severity Classes">Adding Severity Classes</a>
 <li><a href="#Example">How to use <code>fmtmsg</code> and <code>addseverity</code></a>
 </ul>
 </ul>
-<li><a name="toc_Low-Level%20I%2fO"></a>
-    <a href="#Low-Level%20I%2fO">Low-Level Input/Output</a>
+<li><a name="toc_Low-Level I%2fO"></a>
+    <a href="#Low-Level I%2fO">Low-Level Input/Output</a>
 <ul>
-<li><a href="#Opening%20and%20Closing%20Files">Opening and Closing Files</a>
-<li><a href="#I%2fO%20Primitives">Input and Output Primitives</a>
-<li><a href="#File%20Position%20Primitive">Setting the File Position of a Descriptor</a>
-<li><a href="#Descriptors%20and%20Streams">Descriptors and Streams</a>
-<li><a href="#Stream%2fDescriptor%20Precautions">Dangers of Mixing Streams and Descriptors</a>
-<ul>
-<li><a href="#Linked%20Channels">Linked Channels</a>
-<li><a href="#Independent%20Channels">Independent Channels</a>
-<li><a href="#Cleaning%20Streams">Cleaning Streams</a>
+<li><a href="#Opening and Closing Files">Opening and Closing Files</a>
+<li><a href="#I%2fO Primitives">Input and Output Primitives</a>
+<li><a href="#File Position Primitive">Setting the File Position of a Descriptor</a>
+<li><a href="#Descriptors and Streams">Descriptors and Streams</a>
+<li><a href="#Stream%2fDescriptor Precautions">Dangers of Mixing Streams and Descriptors</a>
+<ul>
+<li><a href="#Linked Channels">Linked Channels</a>
+<li><a href="#Independent Channels">Independent Channels</a>
+<li><a href="#Cleaning Streams">Cleaning Streams</a>
 </ul>
 <li><a href="#Scatter-Gather">Fast Scatter-Gather I/O</a>
-<li><a href="#Memory-mapped%20I%2fO">Memory-mapped I/O</a>
-<li><a href="#Waiting%20for%20I%2fO">Waiting for Input or Output</a>
-<li><a href="#Synchronizing%20I%2fO">Synchronizing I/O operations</a>
-<li><a href="#Asynchronous%20I%2fO">Perform I/O Operations in Parallel</a>
-<ul>
-<li><a href="#Asynchronous%20Reads%2fWrites">Asynchronous Read and Write Operations</a>
-<li><a href="#Status%20of%20AIO%20Operations">Getting the Status of AIO Operations</a>
-<li><a href="#Synchronizing%20AIO%20Operations">Getting into a Consistent State</a>
-<li><a href="#Cancel%20AIO%20Operations">Cancellation of AIO Operations</a>
-<li><a href="#Configuration%20of%20AIO">How to optimize the AIO implementation</a>
-</ul>
-<li><a href="#Control%20Operations">Control Operations on Files</a>
-<li><a href="#Duplicating%20Descriptors">Duplicating Descriptors</a>
-<li><a href="#Descriptor%20Flags">File Descriptor Flags</a>
-<li><a href="#File%20Status%20Flags">File Status Flags</a>
-<ul>
-<li><a href="#Access%20Modes">File Access Modes</a>
-<li><a href="#Open-time%20Flags">Open-time Flags</a>
-<li><a href="#Operating%20Modes">I/O Operating Modes</a>
-<li><a href="#Getting%20File%20Status%20Flags">Getting and Setting File Status Flags</a>
+<li><a href="#Memory-mapped I%2fO">Memory-mapped I/O</a>
+<li><a href="#Waiting for I%2fO">Waiting for Input or Output</a>
+<li><a href="#Synchronizing I%2fO">Synchronizing I/O operations</a>
+<li><a href="#Asynchronous I%2fO">Perform I/O Operations in Parallel</a>
+<ul>
+<li><a href="#Asynchronous Reads%2fWrites">Asynchronous Read and Write Operations</a>
+<li><a href="#Status of AIO Operations">Getting the Status of AIO Operations</a>
+<li><a href="#Synchronizing AIO Operations">Getting into a Consistent State</a>
+<li><a href="#Cancel AIO Operations">Cancellation of AIO Operations</a>
+<li><a href="#Configuration of AIO">How to optimize the AIO implementation</a>
+</ul>
+<li><a href="#Control Operations">Control Operations on Files</a>
+<li><a href="#Duplicating Descriptors">Duplicating Descriptors</a>
+<li><a href="#Descriptor Flags">File Descriptor Flags</a>
+<li><a href="#File Status Flags">File Status Flags</a>
+<ul>
+<li><a href="#Access Modes">File Access Modes</a>
+<li><a href="#Open-time Flags">Open-time Flags</a>
+<li><a href="#Operating Modes">I/O Operating Modes</a>
+<li><a href="#Getting File Status Flags">Getting and Setting File Status Flags</a>
 </ul>
-<li><a href="#File%20Locks">File Locks</a>
-<li><a href="#Interrupt%20Input">Interrupt-Driven Input</a>
+<li><a href="#File Locks">File Locks</a>
+<li><a href="#Interrupt Input">Interrupt-Driven Input</a>
 <li><a href="#IOCTLs">Generic I/O Control operations</a>
 </ul>
-<li><a name="toc_File%20System%20Interface"></a>
-    <a href="#File%20System%20Interface">File System Interface</a>
+<li><a name="toc_File System Interface"></a>
+    <a href="#File System Interface">File System Interface</a>
 <ul>
-<li><a href="#Working%20Directory">Working Directory</a>
-<li><a href="#Accessing%20Directories">Accessing Directories</a>
+<li><a href="#Working Directory">Working Directory</a>
+<li><a href="#Accessing Directories">Accessing Directories</a>
 <ul>
-<li><a href="#Directory%20Entries">Format of a Directory Entry</a>
-<li><a href="#Opening%20a%20Directory">Opening a Directory Stream</a>
-<li><a href="#Reading%2fClosing%20Directory">Reading and Closing a Directory Stream</a>
-<li><a href="#Simple%20Directory%20Lister">Simple Program to List a Directory</a>
-<li><a href="#Random%20Access%20Directory">Random Access in a Directory Stream</a>
-<li><a href="#Scanning%20Directory%20Content">Scanning the Content of a Directory</a>
-<li><a href="#Simple%20Directory%20Lister%20Mark%20II">Simple Program to List a Directory, Mark II</a>
-</ul>
-<li><a href="#Working%20with%20Directory%20Trees">Working with Directory Trees</a>
-<li><a href="#Hard%20Links">Hard Links</a>
-<li><a href="#Symbolic%20Links">Symbolic Links</a>
-<li><a href="#Deleting%20Files">Deleting Files</a>
-<li><a href="#Renaming%20Files">Renaming Files</a>
-<li><a href="#Creating%20Directories">Creating Directories</a>
-<li><a href="#File%20Attributes">File Attributes</a>
-<ul>
-<li><a href="#Attribute%20Meanings">The meaning of the File Attributes</a>
-<li><a href="#Reading%20Attributes">Reading the Attributes of a File</a>
-<li><a href="#Testing%20File%20Type">Testing the Type of a File</a>
-<li><a href="#File%20Owner">File Owner</a>
-<li><a href="#Permission%20Bits">The Mode Bits for Access Permission</a>
-<li><a href="#Access%20Permission">How Your Access to a File is Decided</a>
-<li><a href="#Setting%20Permissions">Assigning File Permissions</a>
-<li><a href="#Testing%20File%20Access">Testing Permission to Access a File</a>
-<li><a href="#File%20Times">File Times</a>
-<li><a href="#File%20Size">File Size</a>
-</ul>
-<li><a href="#Making%20Special%20Files">Making Special Files</a>
-<li><a href="#Temporary%20Files">Temporary Files</a>
-</ul>
-<li><a name="toc_Pipes%20and%20FIFOs"></a>
-    <a href="#Pipes%20and%20FIFOs">Pipes and FIFOs</a>
-<ul>
-<li><a href="#Creating%20a%20Pipe">Creating a Pipe</a>
-<li><a href="#Pipe%20to%20a%20Subprocess">Pipe to a Subprocess</a>
-<li><a href="#FIFO%20Special%20Files">FIFO Special Files</a>
-<li><a href="#Pipe%20Atomicity">Atomicity of Pipe I/O</a>
+<li><a href="#Directory Entries">Format of a Directory Entry</a>
+<li><a href="#Opening a Directory">Opening a Directory Stream</a>
+<li><a href="#Reading%2fClosing Directory">Reading and Closing a Directory Stream</a>
+<li><a href="#Simple Directory Lister">Simple Program to List a Directory</a>
+<li><a href="#Random Access Directory">Random Access in a Directory Stream</a>
+<li><a href="#Scanning Directory Content">Scanning the Content of a Directory</a>
+<li><a href="#Simple Directory Lister Mark II">Simple Program to List a Directory, Mark II</a>
+</ul>
+<li><a href="#Working with Directory Trees">Working with Directory Trees</a>
+<li><a href="#Hard Links">Hard Links</a>
+<li><a href="#Symbolic Links">Symbolic Links</a>
+<li><a href="#Deleting Files">Deleting Files</a>
+<li><a href="#Renaming Files">Renaming Files</a>
+<li><a href="#Creating Directories">Creating Directories</a>
+<li><a href="#File Attributes">File Attributes</a>
+<ul>
+<li><a href="#Attribute Meanings">The meaning of the File Attributes</a>
+<li><a href="#Reading Attributes">Reading the Attributes of a File</a>
+<li><a href="#Testing File Type">Testing the Type of a File</a>
+<li><a href="#File Owner">File Owner</a>
+<li><a href="#Permission Bits">The Mode Bits for Access Permission</a>
+<li><a href="#Access Permission">How Your Access to a File is Decided</a>
+<li><a href="#Setting Permissions">Assigning File Permissions</a>
+<li><a href="#Testing File Access">Testing Permission to Access a File</a>
+<li><a href="#File Times">File Times</a>
+<li><a href="#File Size">File Size</a>
+</ul>
+<li><a href="#Making Special Files">Making Special Files</a>
+<li><a href="#Temporary Files">Temporary Files</a>
+</ul>
+<li><a name="toc_Pipes and FIFOs"></a>
+    <a href="#Pipes and FIFOs">Pipes and FIFOs</a>
+<ul>
+<li><a href="#Creating a Pipe">Creating a Pipe</a>
+<li><a href="#Pipe to a Subprocess">Pipe to a Subprocess</a>
+<li><a href="#FIFO Special Files">FIFO Special Files</a>
+<li><a href="#Pipe Atomicity">Atomicity of Pipe I/O</a>
 </ul>
 <li><a name="toc_Sockets"></a>
     <a href="#Sockets">Sockets</a>
 <ul>
-<li><a href="#Socket%20Concepts">Socket Concepts</a>
-<li><a href="#Communication%20Styles">Communication Styles</a>
-<li><a href="#Socket%20Addresses">Socket Addresses</a>
-<ul>
-<li><a href="#Address%20Formats">Address Formats</a>
-<li><a href="#Setting%20Address">Setting the Address of a Socket</a>
-<li><a href="#Reading%20Address">Reading the Address of a Socket</a>
-</ul>
-<li><a href="#Interface%20Naming">Interface Naming</a>
-<li><a href="#Local%20Namespace">The Local Namespace</a>
-<ul>
-<li><a href="#Local%20Namespace%20Concepts">Local Namespace Concepts</a>
-<li><a href="#Local%20Namespace%20Details">Details of Local Namespace</a>
-<li><a href="#Local%20Socket%20Example">Example of Local-Namespace Sockets</a>
-</ul>
-<li><a href="#Internet%20Namespace">The Internet Namespace</a>
-<ul>
-<li><a href="#Internet%20Address%20Formats">Internet Socket Address Formats</a>
-<li><a href="#Host%20Addresses">Host Addresses</a>
-<ul>
-<li><a href="#Abstract%20Host%20Addresses">Internet Host Addresses</a>
-<li><a href="#Host%20Address%20Data%20Type">Host Address Data Type</a>
-<li><a href="#Host%20Address%20Functions">Host Address Functions</a>
-<li><a href="#Host%20Names">Host Names</a>
+<li><a href="#Socket Concepts">Socket Concepts</a>
+<li><a href="#Communication Styles">Communication Styles</a>
+<li><a href="#Socket Addresses">Socket Addresses</a>
+<ul>
+<li><a href="#Address Formats">Address Formats</a>
+<li><a href="#Setting Address">Setting the Address of a Socket</a>
+<li><a href="#Reading Address">Reading the Address of a Socket</a>
+</ul>
+<li><a href="#Interface Naming">Interface Naming</a>
+<li><a href="#Local Namespace">The Local Namespace</a>
+<ul>
+<li><a href="#Local Namespace Concepts">Local Namespace Concepts</a>
+<li><a href="#Local Namespace Details">Details of Local Namespace</a>
+<li><a href="#Local Socket Example">Example of Local-Namespace Sockets</a>
+</ul>
+<li><a href="#Internet Namespace">The Internet Namespace</a>
+<ul>
+<li><a href="#Internet Address Formats">Internet Socket Address Formats</a>
+<li><a href="#Host Addresses">Host Addresses</a>
+<ul>
+<li><a href="#Abstract Host Addresses">Internet Host Addresses</a>
+<li><a href="#Host Address Data Type">Host Address Data Type</a>
+<li><a href="#Host Address Functions">Host Address Functions</a>
+<li><a href="#Host Names">Host Names</a>
 </ul>
 <li><a href="#Ports">Internet Ports</a>
-<li><a href="#Services%20Database">The Services Database</a>
-<li><a href="#Byte%20Order">Byte Order Conversion</a>
-<li><a href="#Protocols%20Database">Protocols Database</a>
-<li><a href="#Inet%20Example">Internet Socket Example</a>
-</ul>
-<li><a href="#Misc%20Namespaces">Other Namespaces</a>
-<li><a href="#Open%2fClose%20Sockets">Opening and Closing Sockets</a>
-<ul>
-<li><a href="#Creating%20a%20Socket">Creating a Socket</a>
-<li><a href="#Closing%20a%20Socket">Closing a Socket</a>
-<li><a href="#Socket%20Pairs">Socket Pairs</a>
+<li><a href="#Services Database">The Services Database</a>
+<li><a href="#Byte Order">Byte Order Conversion</a>
+<li><a href="#Protocols Database">Protocols Database</a>
+<li><a href="#Inet Example">Internet Socket Example</a>
+</ul>
+<li><a href="#Misc Namespaces">Other Namespaces</a>
+<li><a href="#Open%2fClose Sockets">Opening and Closing Sockets</a>
+<ul>
+<li><a href="#Creating a Socket">Creating a Socket</a>
+<li><a href="#Closing a Socket">Closing a Socket</a>
+<li><a href="#Socket Pairs">Socket Pairs</a>
 </ul>
 <li><a href="#Connections">Using Sockets with Connections</a>
 <ul>
 <li><a href="#Connecting">Making a Connection</a>
 <li><a href="#Listening">Listening for Connections</a>
-<li><a href="#Accepting%20Connections">Accepting Connections</a>
-<li><a href="#Who%20is%20Connected">Who is Connected to Me?</a>
-<li><a href="#Transferring%20Data">Transferring Data</a>
-<ul>
-<li><a href="#Sending%20Data">Sending Data</a>
-<li><a href="#Receiving%20Data">Receiving Data</a>
-<li><a href="#Socket%20Data%20Options">Socket Data Options</a>
-</ul>
-<li><a href="#Byte%20Stream%20Example">Byte Stream Socket Example</a>
-<li><a href="#Server%20Example">Byte Stream Connection Server Example</a>
-<li><a href="#Out-of-Band%20Data">Out-of-Band Data</a>
+<li><a href="#Accepting Connections">Accepting Connections</a>
+<li><a href="#Who is Connected">Who is Connected to Me?</a>
+<li><a href="#Transferring Data">Transferring Data</a>
+<ul>
+<li><a href="#Sending Data">Sending Data</a>
+<li><a href="#Receiving Data">Receiving Data</a>
+<li><a href="#Socket Data Options">Socket Data Options</a>
+</ul>
+<li><a href="#Byte Stream Example">Byte Stream Socket Example</a>
+<li><a href="#Server Example">Byte Stream Connection Server Example</a>
+<li><a href="#Out-of-Band Data">Out-of-Band Data</a>
 </ul>
 <li><a href="#Datagrams">Datagram Socket Operations</a>
 <ul>
-<li><a href="#Sending%20Datagrams">Sending Datagrams</a>
-<li><a href="#Receiving%20Datagrams">Receiving Datagrams</a>
-<li><a href="#Datagram%20Example">Datagram Socket Example</a>
-<li><a href="#Example%20Receiver">Example of Reading Datagrams</a>
+<li><a href="#Sending Datagrams">Sending Datagrams</a>
+<li><a href="#Receiving Datagrams">Receiving Datagrams</a>
+<li><a href="#Datagram Example">Datagram Socket Example</a>
+<li><a href="#Example Receiver">Example of Reading Datagrams</a>
 </ul>
 <li><a href="#Inetd">The <code>inetd</code> Daemon</a>
 <ul>
-<li><a href="#Inetd%20Servers"><code>inetd</code> Servers</a>
-<li><a href="#Configuring%20Inetd">Configuring <code>inetd</code></a>
+<li><a href="#Inetd Servers"><code>inetd</code> Servers</a>
+<li><a href="#Configuring Inetd">Configuring <code>inetd</code></a>
 </ul>
-<li><a href="#Socket%20Options">Socket Options</a>
+<li><a href="#Socket Options">Socket Options</a>
 <ul>
-<li><a href="#Socket%20Option%20Functions">Socket Option Functions</a>
-<li><a href="#Socket-Level%20Options">Socket-Level Options</a>
+<li><a href="#Socket Option Functions">Socket Option Functions</a>
+<li><a href="#Socket-Level Options">Socket-Level Options</a>
 </ul>
-<li><a href="#Networks%20Database">Networks Database</a>
-</ul>
-<li><a name="toc_Low-Level%20Terminal%20Interface"></a>
-    <a href="#Low-Level%20Terminal%20Interface">Low-Level Terminal Interface</a>
-<ul>
-<li><a href="#Is%20It%20a%20Terminal">Identifying Terminals</a>
-<li><a href="#I%2fO%20Queues">I/O Queues</a>
-<li><a href="#Canonical%20or%20Not">Two Styles of Input: Canonical or Not</a>
-<li><a href="#Terminal%20Modes">Terminal Modes</a>
-<ul>
-<li><a href="#Mode%20Data%20Types">Terminal Mode Data Types</a>
-<li><a href="#Mode%20Functions">Terminal Mode Functions</a>
-<li><a href="#Setting%20Modes">Setting Terminal Modes Properly</a>
-<li><a href="#Input%20Modes">Input Modes</a>
-<li><a href="#Output%20Modes">Output Modes</a>
-<li><a href="#Control%20Modes">Control Modes</a>
-<li><a href="#Local%20Modes">Local Modes</a>
-<li><a href="#Line%20Speed">Line Speed</a>
-<li><a href="#Special%20Characters">Special Characters</a>
-<ul>
-<li><a href="#Editing%20Characters">Characters for Input Editing</a>
-<li><a href="#Signal%20Characters">Characters that Cause Signals</a>
-<li><a href="#Start%2fStop%20Characters">Special Characters for Flow Control</a>
-<li><a href="#Other%20Special">Other Special Characters</a>
-</ul>
-<li><a href="#Noncanonical%20Input">Noncanonical Input</a>
-</ul>
-<li><a href="#BSD%20Terminal%20Modes">BSD Terminal Modes</a>
-<li><a href="#Line%20Control">Line Control Functions</a>
-<li><a href="#Noncanon%20Example">Noncanonical Mode Example</a>
+<li><a href="#Networks Database">Networks Database</a>
+</ul>
+<li><a name="toc_Low-Level Terminal Interface"></a>
+    <a href="#Low-Level Terminal Interface">Low-Level Terminal Interface</a>
+<ul>
+<li><a href="#Is It a Terminal">Identifying Terminals</a>
+<li><a href="#I%2fO Queues">I/O Queues</a>
+<li><a href="#Canonical or Not">Two Styles of Input: Canonical or Not</a>
+<li><a href="#Terminal Modes">Terminal Modes</a>
+<ul>
+<li><a href="#Mode Data Types">Terminal Mode Data Types</a>
+<li><a href="#Mode Functions">Terminal Mode Functions</a>
+<li><a href="#Setting Modes">Setting Terminal Modes Properly</a>
+<li><a href="#Input Modes">Input Modes</a>
+<li><a href="#Output Modes">Output Modes</a>
+<li><a href="#Control Modes">Control Modes</a>
+<li><a href="#Local Modes">Local Modes</a>
+<li><a href="#Line Speed">Line Speed</a>
+<li><a href="#Special Characters">Special Characters</a>
+<ul>
+<li><a href="#Editing Characters">Characters for Input Editing</a>
+<li><a href="#Signal Characters">Characters that Cause Signals</a>
+<li><a href="#Start%2fStop Characters">Special Characters for Flow Control</a>
+<li><a href="#Other Special">Other Special Characters</a>
+</ul>
+<li><a href="#Noncanonical Input">Noncanonical Input</a>
+</ul>
+<li><a href="#BSD Terminal Modes">BSD Terminal Modes</a>
+<li><a href="#Line Control">Line Control Functions</a>
+<li><a href="#Noncanon Example">Noncanonical Mode Example</a>
 <li><a href="#Pseudo-Terminals">Pseudo-Terminals</a>
 <ul>
 <li><a href="#Allocation">Allocating Pseudo-Terminals</a>
-<li><a href="#Pseudo-Terminal%20Pairs">Opening a Pseudo-Terminal Pair</a>
+<li><a href="#Pseudo-Terminal Pairs">Opening a Pseudo-Terminal Pair</a>
 </ul>
 </ul>
 <li><a name="toc_Syslog"></a>
     <a href="#Syslog">Syslog</a>
 <ul>
-<li><a href="#Overview%20of%20Syslog">Overview of Syslog</a>
-<li><a href="#Submitting%20Syslog%20Messages">Submitting Syslog Messages</a>
+<li><a href="#Overview of Syslog">Overview of Syslog</a>
+<li><a href="#Submitting Syslog Messages">Submitting Syslog Messages</a>
 <ul>
 <li><a href="#openlog">openlog</a>
-<li><a href="#syslog%3b%20vsyslog">syslog, vsyslog</a>
+<li><a href="#syslog%3b vsyslog">syslog, vsyslog</a>
 <li><a href="#closelog">closelog</a>
 <li><a href="#setlogmask">setlogmask</a>
-<li><a href="#Syslog%20Example">Syslog Example</a>
+<li><a href="#Syslog Example">Syslog Example</a>
 </ul>
 </ul>
 <li><a name="toc_Mathematics"></a>
     <a href="#Mathematics">Mathematics</a>
 <ul>
-<li><a href="#Mathematical%20Constants">Predefined Mathematical Constants</a>
-<li><a href="#Trig%20Functions">Trigonometric Functions</a>
-<li><a href="#Inverse%20Trig%20Functions">Inverse Trigonometric Functions</a>
-<li><a href="#Exponents%20and%20Logarithms">Exponentiation and Logarithms</a>
-<li><a href="#Hyperbolic%20Functions">Hyperbolic Functions</a>
-<li><a href="#Special%20Functions">Special Functions</a>
-<li><a href="#Errors%20in%20Math%20Functions">Known Maximum Errors in Math Functions</a>
-<li><a href="#Pseudo-Random%20Numbers">Pseudo-Random Numbers</a>
-<ul>
-<li><a href="#ISO%20Random">ISO C Random Number Functions</a>
-<li><a href="#BSD%20Random">BSD Random Number Functions</a>
-<li><a href="#SVID%20Random">SVID Random Number Function</a>
+<li><a href="#Mathematical Constants">Predefined Mathematical Constants</a>
+<li><a href="#Trig Functions">Trigonometric Functions</a>
+<li><a href="#Inverse Trig Functions">Inverse Trigonometric Functions</a>
+<li><a href="#Exponents and Logarithms">Exponentiation and Logarithms</a>
+<li><a href="#Hyperbolic Functions">Hyperbolic Functions</a>
+<li><a href="#Special Functions">Special Functions</a>
+<li><a href="#Errors in Math Functions">Known Maximum Errors in Math Functions</a>
+<li><a href="#Pseudo-Random Numbers">Pseudo-Random Numbers</a>
+<ul>
+<li><a href="#ISO Random">ISO C Random Number Functions</a>
+<li><a href="#BSD Random">BSD Random Number Functions</a>
+<li><a href="#SVID Random">SVID Random Number Function</a>
 </ul>
-<li><a href="#FP%20Function%20Optimizations">Is Fast Code or Small Code preferred?</a>
+<li><a href="#FP Function Optimizations">Is Fast Code or Small Code preferred?</a>
 </ul>
 <li><a name="toc_Arithmetic"></a>
     <a href="#Arithmetic">Arithmetic Functions</a>
 <ul>
 <li><a href="#Integers">Integers</a>
-<li><a href="#Integer%20Division">Integer Division</a>
-<li><a href="#Floating%20Point%20Numbers">Floating Point Numbers</a>
-<li><a href="#Floating%20Point%20Classes">Floating-Point Number Classification Functions</a>
-<li><a href="#Floating%20Point%20Errors">Errors in Floating-Point Calculations</a>
-<ul>
-<li><a href="#FP%20Exceptions">FP Exceptions</a>
-<li><a href="#Infinity%20and%20NaN">Infinity and NaN</a>
-<li><a href="#Status%20bit%20operations">Examining the FPU status word</a>
-<li><a href="#Math%20Error%20Reporting">Error Reporting by Mathematical Functions</a>
+<li><a href="#Integer Division">Integer Division</a>
+<li><a href="#Floating Point Numbers">Floating Point Numbers</a>
+<li><a href="#Floating Point Classes">Floating-Point Number Classification Functions</a>
+<li><a href="#Floating Point Errors">Errors in Floating-Point Calculations</a>
+<ul>
+<li><a href="#FP Exceptions">FP Exceptions</a>
+<li><a href="#Infinity and NaN">Infinity and NaN</a>
+<li><a href="#Status bit operations">Examining the FPU status word</a>
+<li><a href="#Math Error Reporting">Error Reporting by Mathematical Functions</a>
 </ul>
 <li><a href="#Rounding">Rounding Modes</a>
-<li><a href="#Control%20Functions">Floating-Point Control Functions</a>
-<li><a href="#Arithmetic%20Functions">Arithmetic Functions</a>
+<li><a href="#Control Functions">Floating-Point Control Functions</a>
+<li><a href="#Arithmetic Functions">Arithmetic Functions</a>
 <ul>
-<li><a href="#Absolute%20Value">Absolute Value</a>
-<li><a href="#Normalization%20Functions">Normalization Functions</a>
-<li><a href="#Rounding%20Functions">Rounding Functions</a>
-<li><a href="#Remainder%20Functions">Remainder Functions</a>
-<li><a href="#FP%20Bit%20Twiddling">Setting and modifying single bits of FP values</a>
-<li><a href="#FP%20Comparison%20Functions">Floating-Point Comparison Functions</a>
-<li><a href="#Misc%20FP%20Arithmetic">Miscellaneous FP arithmetic functions</a>
+<li><a href="#Absolute Value">Absolute Value</a>
+<li><a href="#Normalization Functions">Normalization Functions</a>
+<li><a href="#Rounding Functions">Rounding Functions</a>
+<li><a href="#Remainder Functions">Remainder Functions</a>
+<li><a href="#FP Bit Twiddling">Setting and modifying single bits of FP values</a>
+<li><a href="#FP Comparison Functions">Floating-Point Comparison Functions</a>
+<li><a href="#Misc FP Arithmetic">Miscellaneous FP arithmetic functions</a>
 </ul>
-<li><a href="#Complex%20Numbers">Complex Numbers</a>
-<li><a href="#Operations%20on%20Complex">Projections, Conjugates, and Decomposing of Complex Numbers</a>
-<li><a href="#Parsing%20of%20Numbers">Parsing of Numbers</a>
+<li><a href="#Complex Numbers">Complex Numbers</a>
+<li><a href="#Operations on Complex">Projections, Conjugates, and Decomposing of Complex Numbers</a>
+<li><a href="#Parsing of Numbers">Parsing of Numbers</a>
 <ul>
-<li><a href="#Parsing%20of%20Integers">Parsing of Integers</a>
-<li><a href="#Parsing%20of%20Floats">Parsing of Floats</a>
+<li><a href="#Parsing of Integers">Parsing of Integers</a>
+<li><a href="#Parsing of Floats">Parsing of Floats</a>
 </ul>
-<li><a href="#System%20V%20Number%20Conversion">Old-fashioned System V number-to-string functions</a>
+<li><a href="#System V Number Conversion">Old-fashioned System V number-to-string functions</a>
 </ul>
-<li><a name="toc_Date%20and%20Time"></a>
-    <a href="#Date%20and%20Time">Date and Time</a>
+<li><a name="toc_Date and Time"></a>
+    <a href="#Date and Time">Date and Time</a>
 <ul>
-<li><a href="#Time%20Basics">Time Basics</a>
-<li><a href="#Elapsed%20Time">Elapsed Time</a>
-<li><a href="#Processor%20And%20CPU%20Time">Processor And CPU Time</a>
+<li><a href="#Time Basics">Time Basics</a>
+<li><a href="#Elapsed Time">Elapsed Time</a>
+<li><a href="#Processor And CPU Time">Processor And CPU Time</a>
 <ul>
-<li><a href="#CPU%20Time">CPU Time Inquiry</a>
-<li><a href="#Processor%20Time">Processor Time Inquiry</a>
+<li><a href="#CPU Time">CPU Time Inquiry</a>
+<li><a href="#Processor Time">Processor Time Inquiry</a>
 </ul>
-<li><a href="#Calendar%20Time">Calendar Time</a>
+<li><a href="#Calendar Time">Calendar Time</a>
 <ul>
-<li><a href="#Simple%20Calendar%20Time">Simple Calendar Time</a>
-<li><a href="#High-Resolution%20Calendar">High-Resolution Calendar</a>
-<li><a href="#Broken-down%20Time">Broken-down Time</a>
-<li><a href="#High%20Accuracy%20Clock">High Accuracy Clock</a>
-<li><a href="#Formatting%20Calendar%20Time">Formatting Calendar Time</a>
-<li><a href="#Parsing%20Date%20and%20Time">Convert textual time and date information back</a>
+<li><a href="#Simple Calendar Time">Simple Calendar Time</a>
+<li><a href="#High-Resolution Calendar">High-Resolution Calendar</a>
+<li><a href="#Broken-down Time">Broken-down Time</a>
+<li><a href="#High Accuracy Clock">High Accuracy Clock</a>
+<li><a href="#Formatting Calendar Time">Formatting Calendar Time</a>
+<li><a href="#Parsing Date and Time">Convert textual time and date information back</a>
 <ul>
-<li><a href="#Low-Level%20Time%20String%20Parsing">Interpret string according to given format</a>
-<li><a href="#General%20Time%20String%20Parsing">A More User-friendly Way to Parse Times and Dates</a>
+<li><a href="#Low-Level Time String Parsing">Interpret string according to given format</a>
+<li><a href="#General Time String Parsing">A More User-friendly Way to Parse Times and Dates</a>
 </ul>
-<li><a href="#TZ%20Variable">Specifying the Time Zone with <code>TZ</code></a>
-<li><a href="#Time%20Zone%20Functions">Functions and Variables for Time Zones</a>
-<li><a href="#Time%20Functions%20Example">Time Functions Example</a>
+<li><a href="#TZ Variable">Specifying the Time Zone with <code>TZ</code></a>
+<li><a href="#Time Zone Functions">Functions and Variables for Time Zones</a>
+<li><a href="#Time Functions Example">Time Functions Example</a>
 </ul>
-<li><a href="#Setting%20an%20Alarm">Setting an Alarm</a>
+<li><a href="#Setting an Alarm">Setting an Alarm</a>
 <li><a href="#Sleeping">Sleeping</a>
 </ul>
-<li><a name="toc_Resource%20Usage%20And%20Limitation"></a>
-    <a href="#Resource%20Usage%20And%20Limitation">Resource Usage And Limitation</a>
+<li><a name="toc_Resource Usage And Limitation"></a>
+    <a href="#Resource Usage And Limitation">Resource Usage And Limitation</a>
 <ul>
-<li><a href="#Resource%20Usage">Resource Usage</a>
-<li><a href="#Limits%20on%20Resources">Limiting Resource Usage</a>
+<li><a href="#Resource Usage">Resource Usage</a>
+<li><a href="#Limits on Resources">Limiting Resource Usage</a>
 <li><a href="#Priority">Process CPU Priority And Scheduling</a>
 <ul>
-<li><a href="#Absolute%20Priority">Absolute Priority</a>
+<li><a href="#Absolute Priority">Absolute Priority</a>
 <ul>
-<li><a href="#Absolute%20Priority">Using Absolute Priority</a>
+<li><a href="#Absolute Priority">Using Absolute Priority</a>
 </ul>
-<li><a href="#Realtime%20Scheduling">Realtime Scheduling</a>
-<li><a href="#Basic%20Scheduling%20Functions">Basic Scheduling Functions</a>
-<li><a href="#Traditional%20Scheduling">Traditional Scheduling</a>
+<li><a href="#Realtime Scheduling">Realtime Scheduling</a>
+<li><a href="#Basic Scheduling Functions">Basic Scheduling Functions</a>
+<li><a href="#Traditional Scheduling">Traditional Scheduling</a>
 <ul>
-<li><a href="#Traditional%20Scheduling%20Intro">Introduction To Traditional Scheduling</a>
-<li><a href="#Traditional%20Scheduling%20Functions">Functions For Traditional Scheduling</a>
+<li><a href="#Traditional Scheduling Intro">Introduction To Traditional Scheduling</a>
+<li><a href="#Traditional Scheduling Functions">Functions For Traditional Scheduling</a>
 </ul>
 </ul>
-<li><a href="#Memory%20Resources">Querying memory available resources</a>
+<li><a href="#Memory Resources">Querying memory available resources</a>
 <ul>
-<li><a href="#Memory%20Subsystem">Overview about traditional Unix memory handling</a>
-<li><a href="#Query%20Memory%20Parameters">How to get information about the memory subsystem?</a>
+<li><a href="#Memory Subsystem">Overview about traditional Unix memory handling</a>
+<li><a href="#Query Memory Parameters">How to get information about the memory subsystem?</a>
 </ul>
-<li><a href="#Processor%20Resources">Learn about the processors available</a>
+<li><a href="#Processor Resources">Learn about the processors available</a>
 </ul>
-<li><a name="toc_Non-Local%20Exits"></a>
-    <a href="#Non-Local%20Exits">Non-Local Exits</a>
+<li><a name="toc_Non-Local Exits"></a>
+    <a href="#Non-Local Exits">Non-Local Exits</a>
 <ul>
-<li><a href="#Non-Local%20Intro">Introduction to Non-Local Exits</a>
-<li><a href="#Non-Local%20Details">Details of Non-Local Exits</a>
-<li><a href="#Non-Local%20Exits%20and%20Signals">Non-Local Exits and Signals</a>
-<li><a href="#System%20V%20contexts">Complete Context Control</a>
+<li><a href="#Non-Local Intro">Introduction to Non-Local Exits</a>
+<li><a href="#Non-Local Details">Details of Non-Local Exits</a>
+<li><a href="#Non-Local Exits and Signals">Non-Local Exits and Signals</a>
+<li><a href="#System V contexts">Complete Context Control</a>
 </ul>
-<li><a name="toc_Signal%20Handling"></a>
-    <a href="#Signal%20Handling">Signal Handling</a>
+<li><a name="toc_Signal Handling"></a>
+    <a href="#Signal Handling">Signal Handling</a>
 <ul>
-<li><a href="#Concepts%20of%20Signals">Basic Concepts of Signals</a>
+<li><a href="#Concepts of Signals">Basic Concepts of Signals</a>
 <ul>
-<li><a href="#Kinds%20of%20Signals">Some Kinds of Signals</a>
-<li><a href="#Signal%20Generation">Concepts of Signal Generation</a>
-<li><a href="#Delivery%20of%20Signal">How Signals Are Delivered</a>
+<li><a href="#Kinds of Signals">Some Kinds of Signals</a>
+<li><a href="#Signal Generation">Concepts of Signal Generation</a>
+<li><a href="#Delivery of Signal">How Signals Are Delivered</a>
 </ul>
-<li><a href="#Standard%20Signals">Standard Signals</a>
+<li><a href="#Standard Signals">Standard Signals</a>
 <ul>
-<li><a href="#Program%20Error%20Signals">Program Error Signals</a>
-<li><a href="#Termination%20Signals">Termination Signals</a>
-<li><a href="#Alarm%20Signals">Alarm Signals</a>
-<li><a href="#Asynchronous%20I%2fO%20Signals">Asynchronous I/O Signals</a>
-<li><a href="#Job%20Control%20Signals">Job Control Signals</a>
-<li><a href="#Operation%20Error%20Signals">Operation Error Signals</a>
-<li><a href="#Miscellaneous%20Signals">Miscellaneous Signals</a>
-<li><a href="#Signal%20Messages">Signal Messages</a>
+<li><a href="#Program Error Signals">Program Error Signals</a>
+<li><a href="#Termination Signals">Termination Signals</a>
+<li><a href="#Alarm Signals">Alarm Signals</a>
+<li><a href="#Asynchronous I%2fO Signals">Asynchronous I/O Signals</a>
+<li><a href="#Job Control Signals">Job Control Signals</a>
+<li><a href="#Operation Error Signals">Operation Error Signals</a>
+<li><a href="#Miscellaneous Signals">Miscellaneous Signals</a>
+<li><a href="#Signal Messages">Signal Messages</a>
 </ul>
-<li><a href="#Signal%20Actions">Specifying Signal Actions</a>
+<li><a href="#Signal Actions">Specifying Signal Actions</a>
 <ul>
-<li><a href="#Basic%20Signal%20Handling">Basic Signal Handling</a>
-<li><a href="#Advanced%20Signal%20Handling">Advanced Signal Handling</a>
-<li><a href="#Signal%20and%20Sigaction">Interaction of <code>signal</code> and <code>sigaction</code></a>
-<li><a href="#Sigaction%20Function%20Example"><code>sigaction</code> Function Example</a>
-<li><a href="#Flags%20for%20Sigaction">Flags for <code>sigaction</code></a>
-<li><a href="#Initial%20Signal%20Actions">Initial Signal Actions</a>
+<li><a href="#Basic Signal Handling">Basic Signal Handling</a>
+<li><a href="#Advanced Signal Handling">Advanced Signal Handling</a>
+<li><a href="#Signal and Sigaction">Interaction of <code>signal</code> and <code>sigaction</code></a>
+<li><a href="#Sigaction Function Example"><code>sigaction</code> Function Example</a>
+<li><a href="#Flags for Sigaction">Flags for <code>sigaction</code></a>
+<li><a href="#Initial Signal Actions">Initial Signal Actions</a>
 </ul>
-<li><a href="#Defining%20Handlers">Defining Signal Handlers</a>
+<li><a href="#Defining Handlers">Defining Signal Handlers</a>
 <ul>
-<li><a href="#Handler%20Returns">Signal Handlers that Return</a>
-<li><a href="#Termination%20in%20Handler">Handlers That Terminate the Process</a>
-<li><a href="#Longjmp%20in%20Handler">Nonlocal Control Transfer in Handlers</a>
-<li><a href="#Signals%20in%20Handler">Signals Arriving While a Handler Runs</a>
-<li><a href="#Merged%20Signals">Signals Close Together Merge into One</a>
+<li><a href="#Handler Returns">Signal Handlers that Return</a>
+<li><a href="#Termination in Handler">Handlers That Terminate the Process</a>
+<li><a href="#Longjmp in Handler">Nonlocal Control Transfer in Handlers</a>
+<li><a href="#Signals in Handler">Signals Arriving While a Handler Runs</a>
+<li><a href="#Merged Signals">Signals Close Together Merge into One</a>
 <li><a href="#Nonreentrancy">Signal Handling and Nonreentrant Functions</a>
-<li><a href="#Atomic%20Data%20Access">Atomic Data Access and Signal Handling</a>
+<li><a href="#Atomic Data Access">Atomic Data Access and Signal Handling</a>
 <ul>
-<li><a href="#Non-atomic%20Example">Problems with Non-Atomic Access</a>
-<li><a href="#Atomic%20Types">Atomic Types</a>
-<li><a href="#Atomic%20Usage">Atomic Usage Patterns</a>
+<li><a href="#Non-atomic Example">Problems with Non-Atomic Access</a>
+<li><a href="#Atomic Types">Atomic Types</a>
+<li><a href="#Atomic Usage">Atomic Usage Patterns</a>
 </ul>
 </ul>
-<li><a href="#Interrupted%20Primitives">Primitives Interrupted by Signals</a>
-<li><a href="#Generating%20Signals">Generating Signals</a>
+<li><a href="#Interrupted Primitives">Primitives Interrupted by Signals</a>
+<li><a href="#Generating Signals">Generating Signals</a>
 <ul>
-<li><a href="#Signaling%20Yourself">Signaling Yourself</a>
-<li><a href="#Signaling%20Another%20Process">Signaling Another Process</a>
-<li><a href="#Permission%20for%20kill">Permission for using <code>kill</code></a>
-<li><a href="#Kill%20Example">Using <code>kill</code> for Communication</a>
+<li><a href="#Signaling Yourself">Signaling Yourself</a>
+<li><a href="#Signaling Another Process">Signaling Another Process</a>
+<li><a href="#Permission for kill">Permission for using <code>kill</code></a>
+<li><a href="#Kill Example">Using <code>kill</code> for Communication</a>
 </ul>
-<li><a href="#Blocking%20Signals">Blocking Signals</a>
+<li><a href="#Blocking Signals">Blocking Signals</a>
 <ul>
-<li><a href="#Why%20Block">Why Blocking Signals is Useful</a>
-<li><a href="#Signal%20Sets">Signal Sets</a>
-<li><a href="#Process%20Signal%20Mask">Process Signal Mask</a>
-<li><a href="#Testing%20for%20Delivery">Blocking to Test for Delivery of a Signal</a>
-<li><a href="#Blocking%20for%20Handler">Blocking Signals for a Handler</a>
-<li><a href="#Checking%20for%20Pending%20Signals">Checking for Pending Signals</a>
-<li><a href="#Remembering%20a%20Signal">Remembering a Signal to Act On Later</a>
+<li><a href="#Why Block">Why Blocking Signals is Useful</a>
+<li><a href="#Signal Sets">Signal Sets</a>
+<li><a href="#Process Signal Mask">Process Signal Mask</a>
+<li><a href="#Testing for Delivery">Blocking to Test for Delivery of a Signal</a>
+<li><a href="#Blocking for Handler">Blocking Signals for a Handler</a>
+<li><a href="#Checking for Pending Signals">Checking for Pending Signals</a>
+<li><a href="#Remembering a Signal">Remembering a Signal to Act On Later</a>
 </ul>
-<li><a href="#Waiting%20for%20a%20Signal">Waiting for a Signal</a>
+<li><a href="#Waiting for a Signal">Waiting for a Signal</a>
 <ul>
-<li><a href="#Using%20Pause">Using <code>pause</code></a>
-<li><a href="#Pause%20Problems">Problems with <code>pause</code></a>
+<li><a href="#Using Pause">Using <code>pause</code></a>
+<li><a href="#Pause Problems">Problems with <code>pause</code></a>
 <li><a href="#Sigsuspend">Using <code>sigsuspend</code></a>
 </ul>
-<li><a href="#Signal%20Stack">Using a Separate Signal Stack</a>
-<li><a href="#BSD%20Signal%20Handling">BSD Signal Handling</a>
+<li><a href="#Signal Stack">Using a Separate Signal Stack</a>
+<li><a href="#BSD Signal Handling">BSD Signal Handling</a>
 <ul>
-<li><a href="#BSD%20Handler">BSD Function to Establish a Handler</a>
-<li><a href="#Blocking%20in%20BSD">BSD Functions for Blocking Signals</a>
+<li><a href="#BSD Handler">BSD Function to Establish a Handler</a>
+<li><a href="#Blocking in BSD">BSD Functions for Blocking Signals</a>
 </ul>
 </ul>
-<li><a name="toc_Program%20Basics"></a>
-    <a href="#Program%20Basics">The Basic Program/System Interface</a>
+<li><a name="toc_Program Basics"></a>
+    <a href="#Program Basics">The Basic Program/System Interface</a>
 <ul>
-<li><a href="#Program%20Arguments">Program Arguments</a>
+<li><a href="#Program Arguments">Program Arguments</a>
 <ul>
-<li><a href="#Argument%20Syntax">Program Argument Syntax Conventions</a>
-<li><a href="#Parsing%20Program%20Arguments">Parsing Program Arguments</a>
+<li><a href="#Argument Syntax">Program Argument Syntax Conventions</a>
+<li><a href="#Parsing Program Arguments">Parsing Program Arguments</a>
 </ul>
 <li><a href="#Getopt">Parsing program options using <code>getopt</code></a>
 <ul>
-<li><a href="#Using%20Getopt">Using the <code>getopt</code> function</a>
-<li><a href="#Example%20of%20Getopt">Example of Parsing Arguments with <code>getopt</code></a>
-<li><a href="#Getopt%20Long%20Options">Parsing Long Options with <code>getopt_long</code></a>
-<li><a href="#Getopt%20Long%20Option%20Example">Example of Parsing Long Options with <code>getopt_long</code></a>
+<li><a href="#Using Getopt">Using the <code>getopt</code> function</a>
+<li><a href="#Example of Getopt">Example of Parsing Arguments with <code>getopt</code></a>
+<li><a href="#Getopt Long Options">Parsing Long Options with <code>getopt_long</code></a>
+<li><a href="#Getopt Long Option Example">Example of Parsing Long Options with <code>getopt_long</code></a>
 </ul>
 <li><a href="#Argp">Parsing Program Options with Argp</a>
 <ul>
 <li><a href="#Argp">The <code>argp_parse</code> Function</a>
-<li><a href="#Argp%20Global%20Variables">Argp Global Variables</a>
-<li><a href="#Argp%20Parsers">Specifying Argp Parsers</a>
-<li><a href="#Argp%20Option%20Vectors">Specifying Options in an Argp Parser</a>
+<li><a href="#Argp Global Variables">Argp Global Variables</a>
+<li><a href="#Argp Parsers">Specifying Argp Parsers</a>
+<li><a href="#Argp Option Vectors">Specifying Options in an Argp Parser</a>
 <ul>
-<li><a href="#Argp%20Option%20Flags">Flags for Argp Options</a>
+<li><a href="#Argp Option Flags">Flags for Argp Options</a>
 </ul>
-<li><a href="#Argp%20Parser%20Functions">Argp Parser Functions</a>
+<li><a href="#Argp Parser Functions">Argp Parser Functions</a>
 <ul>
-<li><a href="#Argp%20Special%20Keys">Special Keys for Argp Parser Functions</a>
-<li><a href="#Argp%20Helper%20Functions">Functions For Use in Argp Parsers</a>
-<li><a href="#Argp%20Parsing%20State">Argp Parsing State</a>
+<li><a href="#Argp Special Keys">Special Keys for Argp Parser Functions</a>
+<li><a href="#Argp Helper Functions">Functions For Use in Argp Parsers</a>
+<li><a href="#Argp Parsing State">Argp Parsing State</a>
 </ul>
-<li><a href="#Argp%20Children">Combining Multiple Argp Parsers</a>
-<li><a href="#Argp%20Flags">Flags for <code>argp_parse</code></a>
-<li><a href="#Argp%20Help%20Filtering">Customizing Argp Help Output</a>
+<li><a href="#Argp Children">Combining Multiple Argp Parsers</a>
+<li><a href="#Argp Flags">Flags for <code>argp_parse</code></a>
+<li><a href="#Argp Help Filtering">Customizing Argp Help Output</a>
 <ul>
-<li><a href="#Argp%20Help%20Filter%20Keys">Special Keys for Argp Help Filter Functions</a>
+<li><a href="#Argp Help Filter Keys">Special Keys for Argp Help Filter Functions</a>
 </ul>
-<li><a href="#Argp%20Help">The <code>argp_help</code> Function</a>
-<li><a href="#Argp%20Help%20Flags">Flags for the <code>argp_help</code> Function</a>
-<li><a href="#Argp%20Examples">Argp Examples</a>
+<li><a href="#Argp Help">The <code>argp_help</code> Function</a>
+<li><a href="#Argp Help Flags">Flags for the <code>argp_help</code> Function</a>
+<li><a href="#Argp Examples">Argp Examples</a>
 <ul>
-<li><a href="#Argp%20Example%201">A Minimal Program Using Argp</a>
-<li><a href="#Argp%20Example%202">A Program Using Argp with Only Default Options</a>
-<li><a href="#Argp%20Example%203">A Program Using Argp with User Options</a>
-<li><a href="#Argp%20Example%204">A Program Using Multiple Combined Argp Parsers</a>
+<li><a href="#Argp Example 1">A Minimal Program Using Argp</a>
+<li><a href="#Argp Example 2">A Program Using Argp with Only Default Options</a>
+<li><a href="#Argp Example 3">A Program Using Argp with User Options</a>
+<li><a href="#Argp Example 4">A Program Using Multiple Combined Argp Parsers</a>
 </ul>
-<li><a href="#Argp%20User%20Customization">Argp User Customization</a>
+<li><a href="#Argp User Customization">Argp User Customization</a>
 <ul>
 <li><a href="#Suboptions">Parsing of Suboptions</a>
 </ul>
-<li><a href="#Suboptions%20Example">Parsing of Suboptions Example</a>
+<li><a href="#Suboptions Example">Parsing of Suboptions Example</a>
 </ul>
-<li><a href="#Environment%20Variables">Environment Variables</a>
+<li><a href="#Environment Variables">Environment Variables</a>
 <ul>
-<li><a href="#Environment%20Access">Environment Access</a>
-<li><a href="#Standard%20Environment">Standard Environment Variables</a>
+<li><a href="#Environment Access">Environment Access</a>
+<li><a href="#Standard Environment">Standard Environment Variables</a>
 </ul>
-<li><a href="#System%20Calls">System Calls</a>
-<li><a href="#Program%20Termination">Program Termination</a>
+<li><a href="#System Calls">System Calls</a>
+<li><a href="#Program Termination">Program Termination</a>
 <ul>
-<li><a href="#Normal%20Termination">Normal Termination</a>
-<li><a href="#Exit%20Status">Exit Status</a>
-<li><a href="#Cleanups%20on%20Exit">Cleanups on Exit</a>
-<li><a href="#Aborting%20a%20Program">Aborting a Program</a>
-<li><a href="#Termination%20Internals">Termination Internals</a>
+<li><a href="#Normal Termination">Normal Termination</a>
+<li><a href="#Exit Status">Exit Status</a>
+<li><a href="#Cleanups on Exit">Cleanups on Exit</a>
+<li><a href="#Aborting a Program">Aborting a Program</a>
+<li><a href="#Termination Internals">Termination Internals</a>
 </ul>
 </ul>
 <li><a name="toc_Processes"></a>
     <a href="#Processes">Processes</a>
 <ul>
-<li><a href="#Running%20a%20Command">Running a Command</a>
-<li><a href="#Process%20Creation%20Concepts">Process Creation Concepts</a>
-<li><a href="#Process%20Identification">Process Identification</a>
-<li><a href="#Creating%20a%20Process">Creating a Process</a>
-<li><a href="#Executing%20a%20File">Executing a File</a>
-<li><a href="#Process%20Completion">Process Completion</a>
-<li><a href="#Process%20Completion%20Status">Process Completion Status</a>
-<li><a href="#BSD%20Wait%20Functions">BSD Process Wait Functions</a>
-<li><a href="#Process%20Creation%20Example">Process Creation Example</a>
+<li><a href="#Running a Command">Running a Command</a>
+<li><a href="#Process Creation Concepts">Process Creation Concepts</a>
+<li><a href="#Process Identification">Process Identification</a>
+<li><a href="#Creating a Process">Creating a Process</a>
+<li><a href="#Executing a File">Executing a File</a>
+<li><a href="#Process Completion">Process Completion</a>
+<li><a href="#Process Completion Status">Process Completion Status</a>
+<li><a href="#BSD Wait Functions">BSD Process Wait Functions</a>
+<li><a href="#Process Creation Example">Process Creation Example</a>
 </ul>
-<li><a name="toc_Job%20Control"></a>
-    <a href="#Job%20Control">Job Control</a>
+<li><a name="toc_Job Control"></a>
+    <a href="#Job Control">Job Control</a>
 <ul>
-<li><a href="#Concepts%20of%20Job%20Control">Concepts of Job Control</a>
-<li><a href="#Job%20Control%20is%20Optional">Job Control is Optional</a>
-<li><a href="#Controlling%20Terminal">Controlling Terminal of a Process</a>
-<li><a href="#Access%20to%20the%20Terminal">Access to the Controlling Terminal</a>
-<li><a href="#Orphaned%20Process%20Groups">Orphaned Process Groups</a>
-<li><a href="#Implementing%20a%20Shell">Implementing a Job Control Shell</a>
+<li><a href="#Concepts of Job Control">Concepts of Job Control</a>
+<li><a href="#Job Control is Optional">Job Control is Optional</a>
+<li><a href="#Controlling Terminal">Controlling Terminal of a Process</a>
+<li><a href="#Access to the Terminal">Access to the Controlling Terminal</a>
+<li><a href="#Orphaned Process Groups">Orphaned Process Groups</a>
+<li><a href="#Implementing a Shell">Implementing a Job Control Shell</a>
 <ul>
-<li><a href="#Data%20Structures">Data Structures for the Shell</a>
-<li><a href="#Initializing%20the%20Shell">Initializing the Shell</a>
-<li><a href="#Launching%20Jobs">Launching Jobs</a>
-<li><a href="#Foreground%20and%20Background">Foreground and Background</a>
-<li><a href="#Stopped%20and%20Terminated%20Jobs">Stopped and Terminated Jobs</a>
-<li><a href="#Continuing%20Stopped%20Jobs">Continuing Stopped Jobs</a>
-<li><a href="#Missing%20Pieces">The Missing Pieces</a>
+<li><a href="#Data Structures">Data Structures for the Shell</a>
+<li><a href="#Initializing the Shell">Initializing the Shell</a>
+<li><a href="#Launching Jobs">Launching Jobs</a>
+<li><a href="#Foreground and Background">Foreground and Background</a>
+<li><a href="#Stopped and Terminated Jobs">Stopped and Terminated Jobs</a>
+<li><a href="#Continuing Stopped Jobs">Continuing Stopped Jobs</a>
+<li><a href="#Missing Pieces">The Missing Pieces</a>
 </ul>
-<li><a href="#Functions%20for%20Job%20Control">Functions for Job Control</a>
+<li><a href="#Functions for Job Control">Functions for Job Control</a>
 <ul>
-<li><a href="#Identifying%20the%20Terminal">Identifying the Controlling Terminal</a>
-<li><a href="#Process%20Group%20Functions">Process Group Functions</a>
-<li><a href="#Terminal%20Access%20Functions">Functions for Controlling Terminal Access</a>
+<li><a href="#Identifying the Terminal">Identifying the Controlling Terminal</a>
+<li><a href="#Process Group Functions">Process Group Functions</a>
+<li><a href="#Terminal Access Functions">Functions for Controlling Terminal Access</a>
 </ul>
 </ul>
-<li><a name="toc_Name%20Service%20Switch"></a>
-    <a href="#Name%20Service%20Switch">System Databases and Name Service Switch</a>
+<li><a name="toc_Name Service Switch"></a>
+    <a href="#Name Service Switch">System Databases and Name Service Switch</a>
 <ul>
-<li><a href="#NSS%20Basics">NSS Basics</a>
-<li><a href="#NSS%20Configuration%20File">The NSS Configuration File</a>
+<li><a href="#NSS Basics">NSS Basics</a>
+<li><a href="#NSS Configuration File">The NSS Configuration File</a>
 <ul>
-<li><a href="#Services%20in%20the%20NSS%20configuration">Services in the NSS configuration File</a>
-<li><a href="#Actions%20in%20the%20NSS%20configuration">Actions in the NSS configuration</a>
-<li><a href="#Notes%20on%20NSS%20Configuration%20File">Notes on the NSS Configuration File</a>
+<li><a href="#Services in the NSS configuration">Services in the NSS configuration File</a>
+<li><a href="#Actions in the NSS configuration">Actions in the NSS configuration</a>
+<li><a href="#Notes on NSS Configuration File">Notes on the NSS Configuration File</a>
 </ul>
-<li><a href="#NSS%20Module%20Internals">NSS Module Internals</a>
+<li><a href="#NSS Module Internals">NSS Module Internals</a>
 <ul>
-<li><a href="#NSS%20Module%20Names">The Naming Scheme of the NSS Modules</a>
-<li><a href="#NSS%20Modules%20Interface">The Interface of the Function in NSS Modules</a>
+<li><a href="#NSS Module Names">The Naming Scheme of the NSS Modules</a>
+<li><a href="#NSS Modules Interface">The Interface of the Function in NSS Modules</a>
 </ul>
-<li><a href="#Extending%20NSS">Extending NSS</a>
+<li><a href="#Extending NSS">Extending NSS</a>
 <ul>
-<li><a href="#Adding%20another%20Service%20to%20NSS">Adding another Service to NSS</a>
-<li><a href="#NSS%20Module%20Function%20Internals">Internals of the NSS Module Functions</a>
+<li><a href="#Adding another Service to NSS">Adding another Service to NSS</a>
+<li><a href="#NSS Module Function Internals">Internals of the NSS Module Functions</a>
 </ul>
 </ul>
-<li><a name="toc_Users%20and%20Groups"></a>
-    <a href="#Users%20and%20Groups">Users and Groups</a>
+<li><a name="toc_Users and Groups"></a>
+    <a href="#Users and Groups">Users and Groups</a>
 <ul>
-<li><a href="#User%20and%20Group%20IDs">User and Group IDs</a>
-<li><a href="#Process%20Persona">The Persona of a Process</a>
-<li><a href="#Why%20Change%20Persona">Why Change the Persona of a Process?</a>
-<li><a href="#How%20Change%20Persona">How an Application Can Change Persona</a>
-<li><a href="#Reading%20Persona">Reading the Persona of a Process</a>
-<li><a href="#Setting%20User%20ID">Setting the User ID</a>
-<li><a href="#Setting%20Groups">Setting the Group IDs</a>
-<li><a href="#Enable%2fDisable%20Setuid">Enabling and Disabling Setuid Access</a>
-<li><a href="#Setuid%20Program%20Example">Setuid Program Example</a>
-<li><a href="#Tips%20for%20Setuid">Tips for Writing Setuid Programs</a>
-<li><a href="#Who%20Logged%20In">Identifying Who Logged In</a>
-<li><a href="#User%20Accounting%20Database">The User Accounting Database</a>
+<li><a href="#User and Group IDs">User and Group IDs</a>
+<li><a href="#Process Persona">The Persona of a Process</a>
+<li><a href="#Why Change Persona">Why Change the Persona of a Process?</a>
+<li><a href="#How Change Persona">How an Application Can Change Persona</a>
+<li><a href="#Reading Persona">Reading the Persona of a Process</a>
+<li><a href="#Setting User ID">Setting the User ID</a>
+<li><a href="#Setting Groups">Setting the Group IDs</a>
+<li><a href="#Enable%2fDisable Setuid">Enabling and Disabling Setuid Access</a>
+<li><a href="#Setuid Program Example">Setuid Program Example</a>
+<li><a href="#Tips for Setuid">Tips for Writing Setuid Programs</a>
+<li><a href="#Who Logged In">Identifying Who Logged In</a>
+<li><a href="#User Accounting Database">The User Accounting Database</a>
 <ul>
-<li><a href="#Manipulating%20the%20Database">Manipulating the User Accounting Database</a>
-<li><a href="#XPG%20Functions">XPG User Accounting Database Functions</a>
-<li><a href="#Logging%20In%20and%20Out">Logging In and Out</a>
+<li><a href="#Manipulating the Database">Manipulating the User Accounting Database</a>
+<li><a href="#XPG Functions">XPG User Accounting Database Functions</a>
+<li><a href="#Logging In and Out">Logging In and Out</a>
 </ul>
-<li><a href="#User%20Database">User Database</a>
+<li><a href="#User Database">User Database</a>
 <ul>
-<li><a href="#User%20Data%20Structure">The Data Structure that Describes a User</a>
-<li><a href="#Lookup%20User">Looking Up One User</a>
-<li><a href="#Scanning%20All%20Users">Scanning the List of All Users</a>
-<li><a href="#Writing%20a%20User%20Entry">Writing a User Entry</a>
+<li><a href="#User Data Structure">The Data Structure that Describes a User</a>
+<li><a href="#Lookup User">Looking Up One User</a>
+<li><a href="#Scanning All Users">Scanning the List of All Users</a>
+<li><a href="#Writing a User Entry">Writing a User Entry</a>
 </ul>
-<li><a href="#Group%20Database">Group Database</a>
+<li><a href="#Group Database">Group Database</a>
 <ul>
-<li><a href="#Group%20Data%20Structure">The Data Structure for a Group</a>
-<li><a href="#Lookup%20Group">Looking Up One Group</a>
-<li><a href="#Scanning%20All%20Groups">Scanning the List of All Groups</a>
+<li><a href="#Group Data Structure">The Data Structure for a Group</a>
+<li><a href="#Lookup Group">Looking Up One Group</a>
+<li><a href="#Scanning All Groups">Scanning the List of All Groups</a>
 </ul>
-<li><a href="#Database%20Example">User and Group Database Example</a>
-<li><a href="#Netgroup%20Database">Netgroup Database</a>
+<li><a href="#Database Example">User and Group Database Example</a>
+<li><a href="#Netgroup Database">Netgroup Database</a>
 <ul>
-<li><a href="#Netgroup%20Data">Netgroup Data</a>
-<li><a href="#Lookup%20Netgroup">Looking up one Netgroup</a>
-<li><a href="#Netgroup%20Membership">Testing for Netgroup Membership</a>
+<li><a href="#Netgroup Data">Netgroup Data</a>
+<li><a href="#Lookup Netgroup">Looking up one Netgroup</a>
+<li><a href="#Netgroup Membership">Testing for Netgroup Membership</a>
 </ul>
 </ul>
-<li><a name="toc_System%20Management"></a>
-    <a href="#System%20Management">System Management</a>
+<li><a name="toc_System Management"></a>
+    <a href="#System Management">System Management</a>
 <ul>
-<li><a href="#Host%20Identification">Host Identification</a>
-<li><a href="#Platform%20Type">Platform Type Identification</a>
-<li><a href="#Filesystem%20Handling">Controlling and Querying Mounts</a>
+<li><a href="#Host Identification">Host Identification</a>
+<li><a href="#Platform Type">Platform Type Identification</a>
+<li><a href="#Filesystem Handling">Controlling and Querying Mounts</a>
 <ul>
-<li><a href="#Mount%20Information">Mount Information</a>
+<li><a href="#Mount Information">Mount Information</a>
 <ul>
 <li><a href="#fstab">The <code>fstab</code> file</a>
 <li><a href="#mtab">The <code>mtab</code> file</a>
-<li><a href="#Other%20Mount%20Information">Other (Non-libc) Sources of Mount Information</a>
+<li><a href="#Other Mount Information">Other (Non-libc) Sources of Mount Information</a>
 </ul>
 <li><a href="#Mount-Unmount-Remount">Mount, Unmount, Remount</a>
 </ul>
-<li><a href="#System%20Parameters">System Parameters</a>
+<li><a href="#System Parameters">System Parameters</a>
 </ul>
-<li><a name="toc_System%20Configuration"></a>
-    <a href="#System%20Configuration">System Configuration Parameters</a>
+<li><a name="toc_System Configuration"></a>
+    <a href="#System Configuration">System Configuration Parameters</a>
 <ul>
-<li><a href="#General%20Limits">General Capacity Limits</a>
-<li><a href="#System%20Options">Overall System Options</a>
-<li><a href="#Version%20Supported">Which Version of POSIX is Supported</a>
+<li><a href="#General Limits">General Capacity Limits</a>
+<li><a href="#System Options">Overall System Options</a>
+<li><a href="#Version Supported">Which Version of POSIX is Supported</a>
 <li><a href="#Sysconf">Using <code>sysconf</code></a>
 <ul>
-<li><a href="#Sysconf%20Definition">Definition of <code>sysconf</code></a>
-<li><a href="#Constants%20for%20Sysconf">Constants for <code>sysconf</code> Parameters</a>
-<li><a href="#Examples%20of%20Sysconf">Examples of <code>sysconf</code></a>
+<li><a href="#Sysconf Definition">Definition of <code>sysconf</code></a>
+<li><a href="#Constants for Sysconf">Constants for <code>sysconf</code> Parameters</a>
+<li><a href="#Examples of Sysconf">Examples of <code>sysconf</code></a>
 </ul>
 <li><a href="#Minimums">Minimum Values for General Capacity Limits</a>
-<li><a href="#Limits%20for%20Files">Limits on File System Capacity</a>
-<li><a href="#Options%20for%20Files">Optional Features in File Support</a>
-<li><a href="#File%20Minimums">Minimum Values for File System Limits</a>
+<li><a href="#Limits for Files">Limits on File System Capacity</a>
+<li><a href="#Options for Files">Optional Features in File Support</a>
+<li><a href="#File Minimums">Minimum Values for File System Limits</a>
 <li><a href="#Pathconf">Using <code>pathconf</code></a>
-<li><a href="#Utility%20Limits">Utility Program Capacity Limits</a>
-<li><a href="#Utility%20Minimums">Minimum Values for Utility Limits</a>
-<li><a href="#String%20Parameters">String-Valued Parameters</a>
+<li><a href="#Utility Limits">Utility Program Capacity Limits</a>
+<li><a href="#Utility Minimums">Minimum Values for Utility Limits</a>
+<li><a href="#String Parameters">String-Valued Parameters</a>
 </ul>
-<li><a name="toc_Cryptographic%20Functions"></a>
-    <a href="#Cryptographic%20Functions">DES Encryption and Password Handling</a>
+<li><a name="toc_Cryptographic Functions"></a>
+    <a href="#Cryptographic Functions">DES Encryption and Password Handling</a>
 <ul>
-<li><a href="#Legal%20Problems">Legal Problems</a>
+<li><a href="#Legal Problems">Legal Problems</a>
 <li><a href="#getpass">Reading Passwords</a>
 <li><a href="#crypt">Encrypting Passwords</a>
-<li><a href="#DES%20Encryption">DES Encryption</a>
+<li><a href="#DES Encryption">DES Encryption</a>
 </ul>
-<li><a name="toc_Debugging%20Support"></a>
-    <a href="#Debugging%20Support">Debugging support</a>
+<li><a name="toc_Debugging Support"></a>
+    <a href="#Debugging Support">Debugging support</a>
 <ul>
 <li><a href="#Backtraces">Backtraces</a>
 </ul>
-<li><a name="toc_Language%20Features"></a>
-    <a href="#Language%20Features">C Language Facilities in the Library</a>
+<li><a name="toc_Language Features"></a>
+    <a href="#Language Features">C Language Facilities in the Library</a>
 <ul>
-<li><a href="#Consistency%20Checking">Explicitly Checking Internal Consistency</a>
-<li><a href="#Variadic%20Functions">Variadic Functions</a>
+<li><a href="#Consistency Checking">Explicitly Checking Internal Consistency</a>
+<li><a href="#Variadic Functions">Variadic Functions</a>
 <ul>
-<li><a href="#Why%20Variadic">Why Variadic Functions are Used</a>
-<li><a href="#How%20Variadic">How Variadic Functions are Defined and Used</a>
+<li><a href="#Why Variadic">Why Variadic Functions are Used</a>
+<li><a href="#How Variadic">How Variadic Functions are Defined and Used</a>
 <ul>
-<li><a href="#Variadic%20Prototypes">Syntax for Variable Arguments</a>
-<li><a href="#Receiving%20Arguments">Receiving the Argument Values</a>
-<li><a href="#How%20Many%20Arguments">How Many Arguments Were Supplied</a>
-<li><a href="#Calling%20Variadics">Calling Variadic Functions</a>
-<li><a href="#Argument%20Macros">Argument Access Macros</a>
+<li><a href="#Variadic Prototypes">Syntax for Variable Arguments</a>
+<li><a href="#Receiving Arguments">Receiving the Argument Values</a>
+<li><a href="#How Many Arguments">How Many Arguments Were Supplied</a>
+<li><a href="#Calling Variadics">Calling Variadic Functions</a>
+<li><a href="#Argument Macros">Argument Access Macros</a>
 </ul>
-<li><a href="#Variadic%20Example">Example of a Variadic Function</a>
+<li><a href="#Variadic Example">Example of a Variadic Function</a>
 <ul>
-<li><a href="#Old%20Varargs">Old-Style Variadic Functions</a>
+<li><a href="#Old Varargs">Old-Style Variadic Functions</a>
 </ul>
 </ul>
-<li><a href="#Null%20Pointer%20Constant">Null Pointer Constant</a>
-<li><a href="#Important%20Data%20Types">Important Data Types</a>
-<li><a href="#Data%20Type%20Measurements">Data Type Measurements</a>
+<li><a href="#Null Pointer Constant">Null Pointer Constant</a>
+<li><a href="#Important Data Types">Important Data Types</a>
+<li><a href="#Data Type Measurements">Data Type Measurements</a>
 <ul>
-<li><a href="#Width%20of%20Type">Computing the Width of an Integer Data Type</a>
-<li><a href="#Range%20of%20Type">Range of an Integer Type</a>
-<li><a href="#Floating%20Type%20Macros">Floating Type Macros</a>
+<li><a href="#Width of Type">Computing the Width of an Integer Data Type</a>
+<li><a href="#Range of Type">Range of an Integer Type</a>
+<li><a href="#Floating Type Macros">Floating Type Macros</a>
 <ul>
-<li><a href="#Floating%20Point%20Concepts">Floating Point Representation Concepts</a>
-<li><a href="#Floating%20Point%20Parameters">Floating Point Parameters</a>
-<li><a href="#IEEE%20Floating%20Point">IEEE Floating Point</a>
+<li><a href="#Floating Point Concepts">Floating Point Representation Concepts</a>
+<li><a href="#Floating Point Parameters">Floating Point Parameters</a>
+<li><a href="#IEEE Floating Point">IEEE Floating Point</a>
 </ul>
-<li><a href="#Structure%20Measurement">Structure Field Offset Measurement</a>
+<li><a href="#Structure Measurement">Structure Field Offset Measurement</a>
 </ul>
 </ul>
-<li><a name="toc_Library%20Summary"></a>
-    <a href="#Library%20Summary">Summary of Library Facilities</a>
+<li><a name="toc_Library Summary"></a>
+    <a href="#Library Summary">Summary of Library Facilities</a>
 <li><a name="toc_Installation"></a>
     <a href="#Installation">Installing the GNU C Library</a>
 <ul>
-<li><a href="#Configuring%20and%20compiling">Configuring and compiling GNU Libc</a>
-<li><a href="#Running%20make%20install">Installing the C Library</a>
-<li><a href="#Tools%20for%20Compilation">Recommended Tools for Compilation</a>
-<li><a href="#Supported%20Configurations">Supported Configurations</a>
+<li><a href="#Configuring and compiling">Configuring and compiling GNU Libc</a>
+<li><a href="#Running make install">Installing the C Library</a>
+<li><a href="#Tools for Compilation">Recommended Tools for Compilation</a>
+<li><a href="#Supported Configurations">Supported Configurations</a>
 <li><a href="#Linux">Specific advice for Linux systems</a>
-<li><a href="#Reporting%20Bugs">Reporting Bugs</a>
+<li><a href="#Reporting Bugs">Reporting Bugs</a>
 </ul>
 <li><a name="toc_Maintenance"></a>
     <a href="#Maintenance">Library Maintenance</a>
 <ul>
-<li><a href="#Source%20Layout">Adding New Functions</a>
+<li><a href="#Source Layout">Adding New Functions</a>
 <li><a href="#Porting">Porting the GNU C Library</a>
 <ul>
-<li><a href="#Hierarchy%20Conventions">Layout of the <code>sysdeps</code> Directory Hierarchy</a>
-<li><a href="#Porting%20to%20Unix">Porting the GNU C Library to Unix Systems</a>
+<li><a href="#Hierarchy Conventions">Layout of the <code>sysdeps</code> Directory Hierarchy</a>
+<li><a href="#Porting to Unix">Porting the GNU C Library to Unix Systems</a>
 </ul>
 </ul>
 <li><a name="toc_Contributors"></a>
     <a href="#Contributors">Contributors to the GNU C Library</a>
-<li><a name="toc_Free%20Manuals"></a>
-    <a href="#Free%20Manuals">Free Software Needs Free Documentation</a>
+<li><a name="toc_Free Manuals"></a>
+    <a href="#Free Manuals">Free Software Needs Free Documentation</a>
 <li><a name="toc_Copying"></a>
     <a href="#Copying">GNU Lesser General Public License</a>
 <ul>
 <ul>
 <li><a href="#Copying">Preamble</a>
 <li><a href="#Copying">How to Apply These Terms to Your New Libraries</a>
 </ul>
 </ul>
-<li><a name="toc_Documentation%20License"></a>
-    <a href="#Documentation%20License">GNU Free Documentation License</a>
+<li><a name="toc_Documentation License"></a>
+    <a href="#Documentation License">GNU Free Documentation License</a>
 <ul>
 <ul>
-<li><a href="#Documentation%20License">ADDENDUM: How to use this License for your documents</a>
+<li><a href="#Documentation License">ADDENDUM: How to use this License for your documents</a>
 </ul>
 </ul>
-<li><a name="toc_Concept%20Index"></a>
-    <a href="#Concept%20Index">Concept Index</a>
-<li><a name="toc_Type%20Index"></a>
-    <a href="#Type%20Index">Type Index</a>
-<li><a name="toc_Function%20Index"></a>
-    <a href="#Function%20Index">Function and Macro Index</a>
-<li><a name="toc_Variable%20Index"></a>
-    <a href="#Variable%20Index">Variable and Constant Macro Index</a>
-<li><a name="toc_File%20Index"></a>
-    <a href="#File%20Index">Program and File Index</a>
+<li><a name="toc_Concept Index"></a>
+    <a href="#Concept Index">Concept Index</a>
+<li><a name="toc_Type Index"></a>
+    <a href="#Type Index">Type Index</a>
+<li><a name="toc_Function Index"></a>
+    <a href="#Function Index">Function and Macro Index</a>
+<li><a name="toc_Variable Index"></a>
+    <a href="#Variable Index">Variable and Constant Macro Index</a>
+<li><a name="toc_File Index"></a>
+    <a href="#File Index">Program and File Index</a>
 </ul>
 
 <hr><h4>Footnotes</h4>
 <ol type="1">
