OSDN Git Service

2009-04-15 Benjamin Kosnik <bkoz@redhat.com>
authorbkoz <bkoz@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 15 Apr 2009 23:26:59 +0000 (23:26 +0000)
committerbkoz <bkoz@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 15 Apr 2009 23:26:59 +0000 (23:26 +0000)
* doc/xml/manual/status_cxx1998.xml: Update to new table style.

* doc/xml/gnu/gpl-3.0.xml: Add or adjust dbhtml markup.
* doc/xml/gnu/fdl-1.2.xml: Same.
* doc/xml/manual/numerics.xml: Same.
* doc/xml/manual/concurrency.xml: Same.
* doc/xml/manual/intro.xml: Same.
* doc/xml/manual/status_cxxtr1.xml: Same.
* doc/xml/manual/containers.xml: Same.
* doc/xml/manual/io.xml: Same.
* doc/xml/manual/utilities.xml: Same.
* doc/xml/manual/support.xml: Same.
* doc/xml/manual/using.xml: Same.
* doc/xml/manual/localization.xml: Same.
* doc/xml/manual/locale.xml: Same.
* doc/xml/manual/extensions.xml: Same.
* doc/xml/manual/appendix_contributing.xml: Same.
* doc/xml/manual/diagnostics.xml: Same.
* doc/xml/manual/status_cxx200x.xml: Same.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@146139 138bc75d-0d04-0410-961f-82ee72b054a4

19 files changed:
libstdc++-v3/ChangeLog
libstdc++-v3/doc/xml/gnu/fdl-1.2.xml
libstdc++-v3/doc/xml/gnu/gpl-3.0.xml
libstdc++-v3/doc/xml/manual/appendix_contributing.xml
libstdc++-v3/doc/xml/manual/concurrency.xml
libstdc++-v3/doc/xml/manual/containers.xml
libstdc++-v3/doc/xml/manual/diagnostics.xml
libstdc++-v3/doc/xml/manual/extensions.xml
libstdc++-v3/doc/xml/manual/intro.xml
libstdc++-v3/doc/xml/manual/io.xml
libstdc++-v3/doc/xml/manual/locale.xml
libstdc++-v3/doc/xml/manual/localization.xml
libstdc++-v3/doc/xml/manual/numerics.xml
libstdc++-v3/doc/xml/manual/status_cxx1998.xml
libstdc++-v3/doc/xml/manual/status_cxx200x.xml
libstdc++-v3/doc/xml/manual/status_cxxtr1.xml
libstdc++-v3/doc/xml/manual/support.xml
libstdc++-v3/doc/xml/manual/using.xml
libstdc++-v3/doc/xml/manual/utilities.xml

index fe23fad..29b1e0f 100644 (file)
@@ -1,6 +1,28 @@
 2009-04-15  Benjamin Kosnik  <bkoz@redhat.com>
 
-       * doc/xml/manual/status_cxxtr1.xml: Update to  new table style.
+       * doc/xml/manual/status_cxx1998.xml: Update to new table style.
+
+       * doc/xml/gnu/gpl-3.0.xml: Add or adjust dbhtml markup.
+       * doc/xml/gnu/fdl-1.2.xml: Same.
+       * doc/xml/manual/numerics.xml: Same.
+       * doc/xml/manual/concurrency.xml: Same.
+       * doc/xml/manual/intro.xml: Same.
+       * doc/xml/manual/status_cxxtr1.xml: Same.
+       * doc/xml/manual/containers.xml: Same.
+       * doc/xml/manual/io.xml: Same.
+       * doc/xml/manual/utilities.xml: Same.
+       * doc/xml/manual/support.xml: Same.
+       * doc/xml/manual/using.xml: Same.
+       * doc/xml/manual/localization.xml: Same.
+       * doc/xml/manual/locale.xml: Same.
+       * doc/xml/manual/extensions.xml: Same.
+       * doc/xml/manual/appendix_contributing.xml: Same.
+       * doc/xml/manual/diagnostics.xml: Same.
+       * doc/xml/manual/status_cxx200x.xml: Same.
+
+2009-04-15  Benjamin Kosnik  <bkoz@redhat.com>
+
+       * doc/xml/manual/status_cxxtr1.xml: Update to new table style.
        * doc/xml/manual/status_cxx200x.xml: Adjust.
 
 2009-04-14  Benjamin Kosnik  <bkoz@redhat.com>
index 326d89d..8ad3a41 100644 (file)
@@ -1,4 +1,5 @@
 <appendix id="appendix.gfdl-1.2">
+  <?dbhtml filename="appendix_gfdl.html"?>
   <title>GNU Free Documentation License</title>
   <para>
     Copyright (C) 2000, 2001, 2002 Free Software Foundation,
index ffd736f..1d9a8c5 100644 (file)
@@ -2,6 +2,7 @@
 <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
   "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
 <appendix id="appendix.gpl-3.0">
+  <?dbhtml filename="appendix_gpl.html"?>
   <title>
     <acronym>GNU</acronym> General Public License version 3
   </title>
index e57ca08..f61b453 100644 (file)
 </sect1>
 
 <sect1 id="contrib.organization" xreflabel="Source Organization">
+  <?dbhtml filename="source_organization.html"?>
   <title>Directory Layout and Source Conventions</title>
   
   <para>
@@ -313,6 +314,7 @@ indicate a place that may require attention for multi-thread safety.
 </sect1>
 
 <sect1 id="contrib.coding_style" xreflabel="Coding Style">
+  <?dbhtml filename="source_code_style.html"?>
   <title>Coding Style</title>
   <para>
   </para>
@@ -911,6 +913,7 @@ indicate a place that may require attention for multi-thread safety.
 </sect1>  
 
 <sect1 id="contrib.doc_style" xreflabel="Documentation Style">
+  <?dbhtml filename="documentation_style.html"?>
   <title>Documentation Style</title>
   <sect2 id="doc_style.doxygen" xreflabel="doc_style.doxygen">
     <title>Doxygen</title>
@@ -1383,6 +1386,7 @@ table below.
 </sect1>  
 
 <sect1 id="contrib.design_notes" xreflabel="Design Notes">
+  <?dbhtml filename="source_design_notes.html"?>
   <title>Design Notes</title>
   <para>
   </para>
index 7efc295..2a676ed 100644 (file)
@@ -4,7 +4,7 @@
 [ ]>
 
 <chapter id="manual.ext.concurrency" xreflabel="Concurrency Extensions">
-<?dbhtml filename="concurrency.html"?>
+<?dbhtml filename="ext_concurrency.html"?>
 
 <chapterinfo>
   <keywordset>
index a860aba..2b29ba6 100644 (file)
 
 <!-- Chapter 01 : Sequences -->
 <chapter id="manual.containers.sequences" xreflabel="Sequences">
+<?dbhtml filename="sequences.html"?>
   <title>Sequences</title>
 
 <sect1 id="containers.sequences.list" xreflabel="list">
+<?dbhtml filename="list.html"?>
   <title>list</title>
   <sect2 id="sequences.list.size" xreflabel="list::size() is O(n)">
     <title>list::size() is O(n)</title>
@@ -80,6 +82,7 @@
 </sect1>
 
 <sect1 id="containers.sequences.vector" xreflabel="vector">
+<?dbhtml filename="vector.html"?>
   <title>vector</title>
   <para>
   </para>
 
 <!-- Chapter 02 : Associative -->
 <chapter id="manual.containers.associative" xreflabel="Associative">
+<?dbhtml filename="associative.html"?>
   <title>Associative</title>
 
   <sect1 id="containers.associative.insert_hints" xreflabel="Insertion Hints">
 
 
   <sect1 id="containers.associative.bitset" xreflabel="bitset">
+    <?dbhtml filename="bitset.html"?>
     <title>bitset</title>
     <sect2 id="associative.bitset.size_variable" xreflabel="Variable">
       <title>Size Variable</title>
 
 <!-- Chapter 03 : Interacting with C -->
 <chapter id="manual.containers.c" xreflabel="Interacting with C">
+<?dbhtml filename="containers_and_c.html"?>
   <title>Interacting with C</title>
 
   <sect1 id="containers.c.vs_array" xreflabel="Containers vs. Arrays">
index 3497f3c..ebdc6c7 100644 (file)
@@ -23,6 +23,7 @@
 </title>
 
 <chapter id="manual.diagnostics.exceptions" xreflabel="Exceptions">
+  <?dbhtml filename="exceptions.html"?>
   <title>Exceptions</title>
 
   <sect1 id="manual.diagnostics.exceptions.hierarchy" xreflabel="Exception Classes">
index 0aa28c7..a0e75cc 100644 (file)
@@ -57,6 +57,7 @@ extensions, be aware of two things:
 
 <!-- Chapter 01 : Compile Time Checks -->
 <chapter id="manual.ext.compile_checks" xreflabel="Compile Time Checks">
+<?dbhtml filename="ext_compile_checks.html"?>
   <title>Compile Time Checks</title>
   <para>
     Also known as concept checking.
@@ -115,6 +116,7 @@ extensions, be aware of two things:
 
 <!-- Chapter 04 : Allocators -->
 <chapter id="manual.ext.allocator" xreflabel="Allocators">
+<?dbhtml filename="ext_allocators.html"?>
   <title>Allocators</title>
 
   <!-- Section 01 : __mt_alloc -->
@@ -131,6 +133,7 @@ extensions, be aware of two things:
 
 <!-- Chapter 05 : Containers -->
 <chapter id="manual.ext.containers" xreflabel="Containers">
+<?dbhtml filename="ext_containers.html"?>
   <title>Containers</title>
   <para>
   </para>
@@ -266,6 +269,7 @@ extensions, be aware of two things:
 
 <!-- Chapter 06 : Utilities -->
 <chapter id="manual.ext.util" xreflabel="Utilities">
+<?dbhtml filename="ext_utilities.html"?>
   <title>Utilities</title>
   <para>
     The &lt;functional&gt; header contains many additional functors
@@ -335,6 +339,7 @@ get_temporary_buffer(5, (int*)0);
 
 <!-- Chapter 07 : Algorithms -->
 <chapter id="manual.ext.algorithms" xreflabel="Algorithms">
+<?dbhtml filename="ext_algorithms.html"?>
   <title>Algorithms</title>
 <para>25.1.6 (count, count_if) is extended with two more versions of count
    and count_if.  The standard versions return their results.  The
@@ -372,6 +377,7 @@ get_temporary_buffer(5, (int*)0);
 
 <!-- Chapter 08 : Numerics -->
 <chapter id="manual.ext.numerics" xreflabel="Numerics">
+<?dbhtml filename="ext_numerics.html"?>
   <title>Numerics</title>
 <para>26.4, the generalized numeric operations such as accumulate, are extended
    with the following functions:
@@ -396,6 +402,7 @@ get_temporary_buffer(5, (int*)0);
 
 <!-- Chapter 09 : Iterators -->
 <chapter id="manual.ext.iterators" xreflabel="Iterators">
+<?dbhtml filename="ext_iterators.html"?>
   <title>Iterators</title>
 <para>24.3.2 describes <code>struct iterator</code>, which didn't exist in the
    original HP STL implementation (the language wasn't rich enough at the
@@ -419,6 +426,7 @@ get_temporary_buffer(5, (int*)0);
 
 <!-- Chapter 08 : IO -->
 <chapter id="manual.ext.io" xreflabel="IO">
+<?dbhtml filename="ext_io.html"?>
   <title>Input and Output</title>
 
   <para>
@@ -487,8 +495,9 @@ get_temporary_buffer(5, (int*)0);
   </sect1>
 </chapter>
 
-<!-- Chapter 11 : Demangling -->
+<!-- Chapter 09 : Demangling -->
 <chapter id="manual.ext.demangle" xreflabel="Demangling">
+<?dbhtml filename="ext_demangling.html"?>
   <title>Demangling</title>
   <para>
     Transforming C++ ABI identifiers (like RTTI symbols) into the
@@ -572,7 +581,7 @@ int main()
    </para>
 </chapter>
 
-<!-- Chapter 12 : Concurrency -->
+<!-- Chapter 10 : Concurrency -->
 <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" 
            parse="xml" href="concurrency.xml">
 </xi:include>
index d64d8b2..7a5e7ce 100644 (file)
 </title>
 <!-- Chapter 01 : Status -->
 <chapter id="manual.intro.status" xreflabel="Status">
+  <?dbhtml filename="status.html"?>
   <title>Status</title>
 
-
-  <sect1 id="manual.intro.status.standard" xreflabel="Implementation Status">
+  <!-- Section 01 : Implementation Status -->
+  <sect1 id="manual.intro.status.standard" xreflabel="Status">
     <title>Implementation Status</title>
 
-    <!-- Section 01 : Status C++ 1998 -->
+    <!-- Section 01.1 : Status C++ 1998 -->
     <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" 
                parse="xml" href="status_cxx1998.xml">
     </xi:include>
 
-    <!-- Section 02 : Status C++ TR1 -->
+    <!-- Section 01.2 : Status C++ TR1 -->
     <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" 
                parse="xml" href="status_cxxtr1.xml">
     </xi:include>
 
-    <!-- Section 03 : Status C++ 200x -->
+    <!-- Section 01.3 : Status C++ 200x -->
     <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" 
                parse="xml" href="status_cxx200x.xml">
     </xi:include>    
@@ -47,6 +48,7 @@
 
   <!-- Section 02 : License -->
   <sect1 id="manual.intro.status.license" xreflabel="License">
+    <?dbhtml filename="license.html"?>
     <title>License</title>
     <para>
     There are two licenses affecting GNU libstdc++: one for the code,
@@ -181,6 +183,7 @@ requirements of the license of GCC.
   
   <!-- Section 03 : Known Bugs -->
   <sect1 id="manual.intro.status.bugs" xreflabel="Bugs">
+    <?dbhtml filename="bugs.html"?>
     <title>Bugs</title>
 
     <sect2 id="manual.intro.status.bugs.impl" xreflabel="Bugs impl">
@@ -783,6 +786,7 @@ requirements of the license of GCC.
 
 <!-- Chapter 02 : Setup -->
 <chapter id="manual.intro.setup" xreflabel="Setup">
+  <?dbhtml filename="setup.html"?>
   <title>Setup</title>
 
    <para>To transform libstdc++ sources into installed include files
@@ -821,6 +825,7 @@ requirements of the license of GCC.
 
   <!-- Section 03 : Make -->
 <sect1 id="manual.intro.setup.make" xreflabel="Make">
+  <?dbhtml filename="make.html"?>
 <title>Make</title>
    <para>If you have never done this before, you should read the basic
       <ulink url="http://gcc.gnu.org/install/">GCC Installation
index 1108b0d..8431f6f 100644 (file)
@@ -24,6 +24,7 @@
 
 <!-- Chapter 01 : Iostream Objects -->
 <chapter id="manual.io.objects" xreflabel="IO Objects">
+<?dbhtml filename="iostream_objects.html"?>
   <title>Iostream Objects</title>
 
    <para>To minimize the time you have to wait on the compiler, it's good to
 
 <!-- Chapter 02 : Stream Buffers -->
 <chapter id="manual.io.streambufs" xreflabel="Stream Buffers">
+<?dbhtml filename="streambufs.html"?>
   <title>Stream Buffers</title>
 
   <sect1 id="io.streambuf.derived" xreflabel="Derived streambuf Classes">
 
 <!-- Chapter 03 : Memory-based Streams -->
 <chapter id="manual.io.memstreams" xreflabel="Memory Streams">
+<?dbhtml filename="stringstreams.html"?>
   <title>Memory Based Streams</title>
   <sect1 id="manual.io.memstreams.compat" xreflabel="Compatibility strstream">
     <title>Compatibility With strstream</title>
 
 <!-- Chapter 04 : File-based Streams -->
 <chapter id="manual.io.filestreams" xreflabel="File Streams">
+<?dbhtml filename="fstreams.html"?>
   <title>File Based Streams</title>
 
   <sect1 id="manual.io.filestreams.copying_a_file" xreflabel="Copying a File">
 
 <!-- Chapter 03 : Interacting with C -->
 <chapter id="manual.io.c" xreflabel="Interacting with C">
+<?dbhtml filename="io_and_c.html"?>
   <title>Interacting with C</title>
 
 
index 275534d..9cb0a17 100644 (file)
@@ -1,5 +1,4 @@
 <sect1 id="manual.localization.locales.locale" xreflabel="locale">
-<?dbhtml filename="locale.html"?>
  
 <sect1info>
   <keywordset>
index 63fd315..475bee1 100644 (file)
@@ -24,6 +24,7 @@
 
 <!-- Chapter 01 : Locale -->
 <chapter id="manual.localization.locales" xreflabel="Locales">
+<?dbhtml filename="locales.html"?>
   <title>Locales</title>
 
   <!--  Section 01 : locale -->
@@ -34,6 +35,7 @@
 
 <!-- Chapter 02 : Facet -->
 <chapter id="manual.localization.facet" xreflabel="facet">
+<?dbhtml filename="facets.html"?>
   <title>Facets aka Categories</title>
 
   <!--  Section 01 : ctype -->
index 02b1f1d..1385314 100644 (file)
@@ -24,6 +24,7 @@
 
 <!-- Chapter 01 : Complex -->
 <chapter id="manual.numerics.complex" xreflabel="complex">
+<?dbhtml filename="complex.html"?>
   <title>Complex</title>
   <para>
   </para>
@@ -53,6 +54,7 @@
 
 <!-- Chapter 02 : Generalized Operations -->
 <chapter id="manual.numerics.generalized_ops" xreflabel="Generalized Ops">
+<?dbhtml filename="generalized_numeric_operations.html"?>
   <title>Generalized Operations</title>
   <para>
   </para>
@@ -95,6 +97,7 @@
 
 <!-- Chapter 03 : Interacting with C -->
 <chapter id="manual.numerics.c" xreflabel="Interacting with C">
+<?dbhtml filename="numerics_and_c.html"?>
   <title>Interacting with C</title>
 
   <sect1 id="numerics.c.array" xreflabel="Numerics vs. Arrays">
index fc22af0..dde3cc0 100644 (file)
@@ -1,5 +1,5 @@
-<sect2 id="manual.intro.status.standard.1998" xreflabel="Status C++ 1998">
-<?dbhtml filename="standard_cxx1998.html"?>
+<sect2 id="manual.intro.status.standard.1998" xreflabel="ISO C++ 1998">
+<?dbhtml filename="status_iso_cxx1998.html"?>
  
 <sect2info>
   <keywordset>
   </keywordset>
 </sect2info>
 
-<title>C++ 1998</title>
-
-<sect3 id="standard.1998" xreflabel="Status C++ 1998">
-  <title>Checklist</title>
-
-<literallayout>
-   Completion Checklist for the Standard C++ Library
-   Updated: 2003-04-25
-
-   Status Code Legend:
-    M - Missing
-    S - Present as stub.
-    X - Partially implemented, or buggy.
-    T - Implemented, pending test/inspection.
-    V - Verified to pass all available test suites.
-    Q - Qualified by inspection for non-testable correctness.
-    P - Portability verified.
-    C - Certified.
-
-   Lexical notes:
-   Only status codes appear in column 0.  Notes relating to conformance
-   issues appear [in brackets].
-
-   Note that this checklist does not (yet) include all emendations
-   recommended by the ISO Library Working Group:
-   http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-toc.html
-
-   Detailed explanation of status codes:
-
-    M - Missing:  The name is not visible to programs that include
-        the specified header, either at compile or link stage.
-
-    S - Present as stub:  A program can use the name, but no implementation
-        is provided.  Programs that use the name link correctly, but
-        cannot usefully be run.
-
-    X - Partially implemented, or buggy:  Some implementation has been
-        provided, but it is known or believed not to conform fully.
-        It may have an incorrect base class, wrong namespace, wrong
-        storage class, or simply not fully implement requirements.
-        However, it may be sufficiently usable to help test other
-        components.
-
-    T - Implemented, pending test/inspection:  Implementation believed
-        to be complete, and informal testing suggests it is ready for
-        formal verification.
-
-    V - Verified, passes all test suites:  Verified to satisfy all
-        generically testable conformance requirements.
-
-    Q - Qualified by inspection for non-testable correctness:
-        Inspected, "implementation-defined" documentation accepted,
-        local usability criteria satisfied, formally inspected for
-        other untestable conformance.  (Untestable requirements
-        include exception-safety, thread-safety, worst-case
-        complexity, memory cleanliness, usefulness.)
-
-    P - Portability verified:  Qualified on all primary target platforms.
-
-    C - Certified:  Formally certified to have passed all tests,
-        inspections, qualifications; approved under "signing authority"
-        to be used to satisfy contractual guarantees.
-
-   ----------------------------------------------------------------------
-       &lt;algorithm&gt;    &lt;iomanip&gt;    &lt;list&gt;      &lt;ostream&gt;     &lt;streambuf&gt;
-       &lt;bitset&gt;       &lt;ios&gt;        &lt;locale&gt;    &lt;queue&gt;       &lt;string&gt;
-       &lt;complex&gt;      &lt;iosfwd&gt;     &lt;map&gt;       &lt;set&gt;         &lt;typeinfo&gt;
-X      &lt;deque&gt;        &lt;iostream&gt;   &lt;memory&gt;    &lt;sstream&gt;     &lt;utility&gt;
-       &lt;exception&gt;    &lt;istream&gt;    &lt;new&gt;       &lt;stack&gt;       &lt;valarray&gt;
-       &lt;fstream&gt;      &lt;iterator&gt;   &lt;numeric&gt;   &lt;stdexcept&gt;   &lt;vector&gt;
-       &lt;functional&gt;   &lt;limits&gt;
-
-   [C header names must be in std:: to qualify.  Related to shadow/ dir.]
-           &lt;cassert&gt; &lt;ciso646&gt; &lt;csetjmp&gt; &lt;cstdio&gt;  &lt;ctime&gt;
-           &lt;cctype&gt;  &lt;climits&gt; &lt;csignal&gt; &lt;cstdlib&gt; &lt;cwchar&gt;
-X          &lt;cerrno&gt;  &lt;clocale&gt; &lt;cstdarg&gt; &lt;cstring&gt; &lt;cwctype&gt;
-           &lt;cfloat&gt;  &lt;cmath&gt;   &lt;cstddef&gt;
-
-    Macro:
-X   errno,  declared  or  defined in &lt;cerrno&gt;.
-
-    Macro fn:
-X   setjmp(jmp_buf), declared or defined in &lt;csetjmp&gt;
-X   va_end(va_list), declared or defined in &lt;cstdarg&gt;
-
-    Types:
-X   clock_t, div_t, FILE, fpos_t, lconv, ldiv_t, mbstate_t,
-X   ptrdiff_t, sig_atomic_t, size_t,  time_t,  tm,  va_list,
-X   wctrans_t, wctype_t, and wint_t.
-
-   1 Which  of  the functions in the C++ Standard Library are not reentrant
-    subroutines is implementation-defined.
-
-   18.1  Types                                        [lib.support.types]
-X      &lt;cstddef&gt;
-X      NULL
-X      offsetof
-X      ptrdiff_t
-X      size_t
-
-   18.2  Implementation properties                   [lib.support.limits]
-
-    &lt;limits&gt;, &lt;climits&gt;, and &lt;cfloat&gt;
-
-   18.2.1  Numeric limits                                    [lib.limits]
-
-X   template&lt;class T&gt; class numeric_limits;
-
-T   enum float_round_style;
-T   enum float_denorm_style;
-
-T   template&lt;&gt; class numeric_limits&lt;bool&gt;;
-
-T   template&lt;&gt; class numeric_limits&lt;char&gt;;
-T   template&lt;&gt; class numeric_limits&lt;signed char&gt;;
-T   template&lt;&gt; class numeric_limits&lt;unsigned char&gt;;
-T   template&lt;&gt; class numeric_limits&lt;wchar_t&gt;;
-
-T   template&lt;&gt; class numeric_limits&lt;short&gt;;
-T   template&lt;&gt; class numeric_limits&lt;int&gt;;
-T   template&lt;&gt; class numeric_limits&lt;long&gt;;
-T   template&lt;&gt; class numeric_limits&lt;unsigned short&gt;;
-T   template&lt;&gt; class numeric_limits&lt;unsigned int&gt;;
-T   template&lt;&gt; class numeric_limits&lt;unsigned long&gt;;
-
-X   template&lt;&gt; class numeric_limits&lt;float&gt;;
-X   template&lt;&gt; class numeric_limits&lt;double&gt;;
-X   template&lt;&gt; class numeric_limits&lt;long double&gt;;
-
-   18.2.1.1  Template class numeric_limits           [lib.numeric.limits]
-T   template&lt;class T&gt; class numeric_limits {
-    public:
-T     static const bool is_specialized = false;
-T     static T min() throw();
-T     static T max() throw();
-T     static const int  digits = 0;
-T     static const int  digits10 = 0;
-T     static const bool is_signed = false;
-T     static const bool is_integer = false;
-T     static const bool is_exact = false;
-T     static const int  radix = 0;
-T     static T epsilon() throw();
-T     static T round_error() throw();
-
-T     static const int  min_exponent = 0;
-T     static const int  min_exponent10 = 0;
-T     static const int  max_exponent = 0;
-T     static const int  max_exponent10 = 0;
-
-T     static const bool has_infinity = false;
-T     static const bool has_quiet_NaN = false;
-T     static const bool has_signaling_NaN = false;
-T     static const float_denorm_style has_denorm = denorm_absent;
-T     static const bool has_denorm_loss = false;
-T     static T infinity() throw();
-T     static T quiet_NaN() throw();
-T     static T signaling_NaN() throw();
-T     static T denorm_min() throw();
-
-T     static const bool is_iec559 = false;
-T     static const bool is_bounded = false;
-T     static const bool is_modulo = false;
-
-T     static const bool traps = false;
-T     static const bool tinyness_before = false;
-T     static const float_round_style round_style = round_toward_zero;
-    };
-
-   18.2.1.3  Type float_round_style                     [lib.round.style]
-
-T   enum float_round_style {
-T     round_indeterminate       = -1,
-T     round_toward_zero         =  0,
-T     round_to_nearest          =  1,
-T     round_toward_infinity     =  2,
-T     round_toward_neg_infinity =  3
-    };
-
-   18.2.1.4  Type float_denorm_style                   [lib.denorm.style]
-
-T   enum float_denorm_style {
-T     denorm_indeterminate = -1;
-T     denorm_absent = 0;
-T     denorm present = 1;
-    };
-
-   18.2.1.5  numeric_limits specializations         [lib.numeric.special]
-   
-   [Note: see Note at 18.2.1.  ]
-
-   18.2.2  C Library                                       [lib.c.limits]
-
-   1 Header &lt;climits&gt; (Table 3):
-      CHAR_BIT   INT_MAX    LONG_MIN     SCHAR_MIN   UCHAR_MAX   USHRT_MAX
-X     CHAR_MAX   INT_MIN    MB_LEN_MAX   SHRT_MAX    UINT_MAX
-      CHAR_MIN   LONG_MAX   SCHAR_MAX    SHRT_MIN    ULONG_MAX
-
-   3 Header &lt;cfloat&gt; (Table 4):
-
-    DBL_DIG          DBL_MIN_EXP      FLT_MIN_10_EXP   LDBL_MAX_10_EXP
-    DBL_EPSILON      FLT_DIG          FLT_MIN_EXP      LDBL_MAX_EXP
-    DBL_MANT_DIG     FLT_EPSILON      FLT_RADIX        LDBL_MIN
-X   DBL_MAX          FLT_MANT_DIG     FLT_ROUNDS       LDBL_MIN_10_EXP
-    DBL_MAX_10_EXP   FLT_MAX          LDBL_DIG         LDBL_MIN_EXP
-    DBL_MAX_EXP      FLT_MAX_10_EXP   LDBL_EPSILON
-    DBL_MIN          FLT_MAX_EXP      LDBL_MANT_DIG
-    DBL_MIN_10_EXP   FLT_MIN          LDBL_MAX
-
-
-        1 Header &lt;cstdlib&gt; (partial), Table 5:
-X             EXIT_FAILURE     EXIT_SUCCESS
-              abort   atexit   exit
-
-S    abort(void)
-S    extern "C" int atexit(void (*f)(void))
-S    extern "C++" int atexit(void (*f)(void))
-S    exit(int status)
-
-   18.4  Dynamic memory management                  [lib.support.dynamic]
-
-   Header &lt;new&gt; synopsis
-
-T    class bad_alloc;
-T    struct nothrow_t {};
-T    extern const nothrow_t nothrow;
-T    typedef void (*new_handler)();
-T    new_handler set_new_handler(new_handler new_p) throw();
-
-T    void* operator new(std::size_t size) throw(std::bad_alloc);
-T    void* operator new(std::size_t size, const std::nothrow_t&amp;) throw();
-T    void  operator delete(void* ptr) throw();
-T    void  operator delete(void* ptr, const std::nothrow_t&amp;) throw();
-T    void* operator new[](std::size_t size) throw(std::bad_alloc);
-T    void* operator new[](std::size_t size, const std::nothrow_t&amp;) throw();
-T    void  operator delete[](void* ptr) throw();
-T    void  operator delete[](void* ptr, const std::nothrow_t&amp;) throw();
-T    void* operator new  (std::size_t size, void* ptr) throw();
-T    void* operator new[](std::size_t size, void* ptr) throw();
-T    void  operator delete  (void* ptr, void*) throw();
-T    void  operator delete[](void* ptr, void*) throw();
-
-   18.4.2.1  Class bad_alloc                              [lib.bad.alloc]
-
-T   class bad_alloc : public exception {
-    public:
-T     bad_alloc() throw();
-T     bad_alloc(const bad_alloc&amp;) throw();
-T     bad_alloc&amp; operator=(const bad_alloc&amp;) throw();
-T     virtual ~bad_alloc() throw();
-T     virtual const char* what() const throw();
-
-
-
-T  new_handler set_new_handler(new_handler new_p) throw();
-
-
-     Header &lt;typeinfo&gt; synopsis
-
-T    class type_info;
-T    class bad_cast;
-T    class bad_typeid;
-
-   18.5.1 - Class type_info [lib.type.info]
-
-T    class type_info {
-    public:
-T      virtual ~type_info();
-T      bool operator==(const type_info&amp; rhs) const;
-T      bool operator!=(const type_info&amp; rhs) const;
-T      bool before(const type_info&amp; rhs) const;
-T      const char* name() const;
-    private:
-T      type_info(const type_info&amp; rhs);
-T      type_info&amp; operator=(const type_info&amp; rhs);
-    };
-
-   18.5.2 - Class bad_cast [lib.bad.cast]
-
-T  bad_cast() throw();
-T  virtual const char* bad_cast::what() const throw();
-
-   18.5.3  Class bad_typeid                              [lib.bad.typeid]
-
-T    class bad_typeid : public exception {
-    public:
-T      bad_typeid() throw();
-T      bad_typeid(const bad_typeid&amp;) throw();
-T      bad_typeid&amp; operator=(const bad_typeid&amp;) throw();
-T      virtual ~bad_typeid() throw();
-T      virtual const char* what() const throw();
-    };
-
-   18.6  Exception handling                       [lib.support.exception]
-
-T      Header &lt;exception&gt; synopsis
-
-T    class exception;
-T    class bad_exception;
-
-T    typedef void (*unexpected_handler)();
-T    unexpected_handler set_unexpected(unexpected_handler f) throw();
-T    void unexpected();
-T    typedef void (*terminate_handler)();
-T    terminate_handler set_terminate(terminate_handler f) throw();
-T    void terminate();
-T    bool uncaught_exception();
-
-   18.6.1  Class exception                                [lib.exception]
-
-T    class exception {
-     public:
-T      exception() throw();
-T      exception(const exception&amp;) throw();
-T      exception&amp; operator=(const exception&amp;) throw();
-T      virtual ~exception() throw();
-T      virtual const char* what() const throw();
-    };
-
-   18.6.2.1  Class bad_exception                      [lib.bad.exception]
-T    class bad_exception : public exception {
-    public:
-T      bad_exception() throw();
-T      bad_exception(const bad_exception&amp;) throw();
-T      bad_exception&amp; operator=(const bad_exception&amp;) throw();
-T      virtual ~bad_exception() throw();
-T      virtual const char* what() const throw();
-    };
-
-   18.7  Other runtime support                      [lib.support.runtime]
-
-   1 Headers &lt;cstdarg&gt; (variable arguments),  &lt;csetjmp&gt;  (nonlocal  jumps),
-    &lt;ctime&gt;  (system  clock clock(), time()), &lt;csignal&gt; (signal handling),
-    and &lt;cstdlib&gt; (runtime environment getenv(), system()).
-
-                    Table 6--Header &lt;cstdarg&gt; synopsis
-                 Macros:   va_arg    va_end   va_start
-X                Type:     va_list
-
-                    Table 7--Header &lt;csetjmp&gt; synopsis
-
-                          Macro:      setjmp |
-X                         Type:       jmp_buf
-                          Function:   longjmp
-
-                     Table 8--Header &lt;ctime&gt; synopsis
-
-                      Macros:      CLOCKS_PER_SEC
-X                     Types:       clock_t
-                      Functions:   clock
-
-                    Table 9--Header &lt;csignal&gt; synopsis
-
-X        Macros:      SIGABRT        SIGILL   SIGSEGV   SIG_DFL
-         SIG_IGN      SIGFPE         SIGINT   SIGTERM   SIG_ERR
-         Type:        sig_atomic_t
-         Functions:   raise          signal
-
-                   Table 10--Header &lt;cstdlib&gt; synopsis
-
-X                     Functions:   getenv   system
-
-   19.1  Exception classes                           [lib.std.exceptions]
-
-   Header &lt;stdexcept&gt; synopsis
-
-T     class logic_error;
-T     class domain_error;
-T     class invalid_argument;
-T     class length_error;
-T     class out_of_range;
-T     class runtime_error;
-T     class range_error;
-T     class overflow_error;
-T     class underflow_error;
-
-   19.1.1  Class logic_error                            [lib.logic.error]
-T   class logic_error : public exception {
-    public:
-T     explicit logic_error(const string&amp; what_arg);
-    };
-
-   19.1.2  Class domain_error                          [lib.domain.error]
-
-T   class domain_error : public logic_error {
-    public:
-T     explicit domain_error(const string&amp; what_arg);
-    };
-
-   19.1.3  Class invalid_argument                  [lib.invalid.argument]
-
-T   class invalid_argument : public logic_error {
-    public:
-T     explicit invalid_argument(const string&amp; what_arg);
-    };
-
-   19.1.4  Class length_error                          [lib.length.error]
-
-T   class length_error : public logic_error {
-    public:
-T     explicit length_error(const string&amp; what_arg);
-    };
-
-   19.1.5  Class out_of_range                          [lib.out.of.range]
-
-T   class out_of_range : public logic_error {
-    public:
-T     explicit out_of_range(const string&amp; what_arg);
-    };
-
-
-   19.1.6  Class runtime_error                        [lib.runtime.error]
-
-T   class runtime_error : public exception {
-    public:
-T     explicit runtime_error(const string&amp; what_arg);
-    };
-
-
-   19.1.7  Class range_error                            [lib.range.error]
-
-T   class range_error : public runtime_error {
-    public:
-T     explicit range_error(const string&amp; what_arg);
-    };
-
-   19.1.8  Class overflow_error                      [lib.overflow.error]
-
-T   class overflow_error : public runtime_error {
-    public:
-T     explicit overflow_error(const string&amp; what_arg);
-    };
-
-
-   19.1.9  Class underflow_error                    [lib.underflow.error]
-
-T   class underflow_error : public runtime_error {
-    public:
-T     explicit underflow_error(const string&amp; what_arg);
-    };
-
-
-   19.2  Assertions                                      [lib.assertions]
-
-                    Table 2--Header &lt;cassert&gt; synopsis
-
-X                         Macro:   assert
-
-   19.3  Error numbers                                        [lib.errno]
-
-                    Table 3--Header &lt;cerrno&gt; synopsis
-
-X                    |Macros:   EDOM   ERANGE   errno |
-
-
-   20.2  Utility components                                 [lib.utility]
-
-   Header &lt;utility&gt; synopsis
-
-    // _lib.operators_, operators:
-T    namespace rel_ops {
-T      template&lt;class T&gt; bool operator!=(const T&amp;, const T&amp;);
-T      template&lt;class T&gt; bool operator&gt; (const T&amp;, const T&amp;);
-T      template&lt;class T&gt; bool operator&lt;=(const T&amp;, const T&amp;);
-T      template&lt;class T&gt; bool operator&gt;=(const T&amp;, const T&amp;);
-    }
-    // _lib.pairs_, pairs:
-T   template &lt;class T1, class T2&gt; struct pair;
-T   template &lt;class T1, class T2&gt;
-      bool operator==(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
-T   template &lt;class T1, class T2&gt;
-      bool operator&lt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
-T   template &lt;class T1, class T2&gt;
-      bool operator!=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
-T   template &lt;class T1, class T2&gt;
-      bool operator&gt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
-T   template &lt;class T1, class T2&gt;
-      bool operator&gt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
-T   template &lt;class T1, class T2&gt;
-      bool operator&lt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
-T   template &lt;class T1, class T2&gt; pair&lt;T1,T2&gt; make_pair(const T1&amp;, const T2&amp;);
-
-
-   20.2.2  Pairs                                              [lib.pairs]
-
-T  template &lt;class T1, class T2&gt;
-   struct pair {
-T    typedef T1 first_type;
-T    typedef T2 second_type;
-
-T    T1 first;
-T    T2 second;
-T    pair();
-T    pair(const T1&amp; x, const T2&amp; y);
-T    template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt; &amp;p);
-   };
-
-   20.3  Function objects                          [lib.function.objects]
-
-   Header &lt;functional&gt; synopsis
-
-    // _lib.base_, base:
-V   template &lt;class Arg, class Result&gt; struct unary_function;
-V   template &lt;class Arg1, class Arg2, class Result&gt; struct binary_function;
-
-    // _lib.arithmetic.operations_, arithmetic operations:
-V   template &lt;class T&gt; struct plus;
-V   template &lt;class T&gt; struct minus;
-V   template &lt;class T&gt; struct multiplies;
-V   template &lt;class T&gt; struct divides;
-V   template &lt;class T&gt; struct modulus;
-V   template &lt;class T&gt; struct negate;
-    // _lib.comparisons_, comparisons:
-V   template &lt;class T&gt; struct equal_to;
-V   template &lt;class T&gt; struct not_equal_to;
-V   template &lt;class T&gt; struct greater;
-V   template &lt;class T&gt; struct less;
-V   template &lt;class T&gt; struct greater_equal;
-V   template &lt;class T&gt; struct less_equal;
-    // _lib.logical.operations_, logical operations:
-V   template &lt;class T&gt; struct logical_and;
-V   template &lt;class T&gt; struct logical_or;
-V   template &lt;class T&gt; struct logical_not;
-    // _lib.negators_, negators:
-    template &lt;class Predicate&gt; struct unary_negate;
-V   template &lt;class Predicate&gt;
-      unary_negate&lt;Predicate&gt;  not1(const Predicate&amp;);
-V   template &lt;class Predicate&gt; struct binary_negate;
-V   template &lt;class Predicate&gt;
-      binary_negate&lt;Predicate&gt; not2(const Predicate&amp;);
-    // _lib.binders_, binders:
-V   template &lt;class Operation&gt;  class binder1st;
-V   template &lt;class Operation, class T&gt;
-      binder1st&lt;Operation&gt; bind1st(const Operation&amp;, const T&amp;);
-V   template &lt;class Operation&gt; class binder2nd;
-V   template &lt;class Operation, class T&gt;
-      binder2nd&lt;Operation&gt; bind2nd(const Operation&amp;, const T&amp;);
-    // _lib.function.pointer.adaptors_, adaptors:
-V   template &lt;class Arg, class Result&gt; class pointer_to_unary_function;
-V   template &lt;class Arg, class Result&gt;
-      pointer_to_unary_function&lt;Arg,Result&gt; ptr_fun(Result (*)(Arg));
-V   template &lt;class Arg1, class Arg2, class Result&gt;
-      class pointer_to_binary_function;
-V   template &lt;class Arg1, class Arg2, class Result&gt;
-      pointer_to_binary_function&lt;Arg1,Arg2,Result&gt;
-        ptr_fun(Result (*)(Arg1,Arg2));
-
-    // _lib.member.pointer.adaptors_, adaptors:
-V   template&lt;class S, class T&gt; class mem_fun_t;
-V   template&lt;class S, class T, class A&gt; class mem_fun1_t;
-V   template&lt;class S, class T&gt;
-        mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)());
-V   template&lt;class S, class T, class A&gt;
-        mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A));
-V   template&lt;class S, class T&gt; class mem_fun_ref_t;
-V   template&lt;class S, class T, class A&gt; class mem_fun1_ref_t;
-V   template&lt;class S, class T&gt;
-        mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)());
-V   template&lt;class S, class T, class A&gt;
-        mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A));
-
-V   template &lt;class S, class T&gt; class const_mem_fun_t;
-V   template &lt;class S, class T, class A&gt; class const_mem_fun1_t;
-V   template &lt;class S, class T&gt;
-      const_mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)() const);
-V   template &lt;class S, class T, class A&gt;
-      const_mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A) const);
-V   template &lt;class S, class T&gt; class const_mem_fun_ref_t;
-V   template &lt;class S, class T, class A&gt; class const_mem_fun1_ref_t;
-V   template &lt;class S, class T&gt;
-      const_mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)() const);
-V   template &lt;class S, class T, class A&gt;
-      const_mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A) const);
-   }
-
-   20.3.1  Base                                                [lib.base]
-
-V   template &lt;class Arg, class Result&gt;
-    struct unary_function {
-V     typedef Arg    argument_type;
-V     typedef Result result_type;
-    };
-V   template &lt;class Arg1, class Arg2, class Result&gt;
-    struct binary_function {
-V     typedef Arg1   first_argument_type;
-V     typedef Arg2   second_argument_type;
-V     typedef Result result_type;
-    };
-
-   20.3.2  Arithmetic operations              [lib.arithmetic.operations]
-
-T  template &lt;class T&gt; struct plus : binary_function&lt;T,T,T&gt; {
-V   T operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct minus : binary_function&lt;T,T,T&gt; {
-V   T operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct multiplies : binary_function&lt;T,T,T&gt; {
-V   T operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct divides : binary_function&lt;T,T,T&gt; {
-V   T operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct modulus : binary_function&lt;T,T,T&gt; {
-V   T operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct negate : unary_function&lt;T,T&gt; {
-V   T operator()(const T&amp; x) const;
-   };
-
-   20.3.3  Comparisons                                  [lib.comparisons]
-
-T  template &lt;class T&gt; struct equal_to : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct not_equal_to : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct greater : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct less : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct greater_equal : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct less_equal : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-   20.3.4  Logical operations                    [lib.logical.operations]
-
-T  template &lt;class T&gt; struct logical_and : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct logical_or : binary_function&lt;T,T,bool&gt; {
-V   bool operator()(const T&amp; x, const T&amp; y) const;
-   };
-
-T  template &lt;class T&gt; struct logical_not : unary_function&lt;T,bool&gt; {
-V   bool operator()(const T&amp; x) const;
-   };
-
-   20.3.5  Negators                                        [lib.negators]
-
-T  template &lt;class Predicate&gt;
-    class unary_negate
-      : public unary_function&lt;typename Predicate::argument_type,bool&gt; {
-   public:
-T   explicit unary_negate(const Predicate&amp; pred);
-V   bool operator()(const typename Predicate::argument_type&amp; x) const;
-   };
-
-T  template &lt;class Predicate&gt;
-    class binary_negate
-      : public binary_function&lt;typename Predicate::first_argument_type,
-          typename Predicate::second_argument_type, bool&gt; {
-    public:
-T     explicit binary_negate(const Predicate&amp; pred);
-V     bool operator()(const typename Predicate::first_argument_type&amp;  x,
-          const typename Predicate::second_argument_type&amp; y) const;
-    };
-
-
-   20.3.6  Binders                                          [lib.binders]
-
-   20.3.6.1  Template class binder1st                    [lib.binder.1st]
-T   template &lt;class Operation&gt;
-    class binder1st
-      : public unary_function&lt;typename Operation::second_argument_type,
-                              typename Operation::result_type&gt; {
-    protected:
-T     Operation                      op;
-T     typename Operation::first_argument_type value;
-    public:
-V     binder1st(const Operation&amp; x,
-                const typename Operation::first_argument_type&amp; y);
-V     typename Operation::result_type
-        operator()(const typename Operation::second_argument_type&amp; x) const;
-    };
-
-   20.3.6.2  bind1st                                       [lib.bind.1st]
-
-V  template &lt;class Operation, class T&gt;
-    binder1st&lt;Operation&gt; bind1st(const Operation&amp; op, const T&amp; x);
-
-   20.3.6.3  Template class binder2nd                    [lib.binder.2nd]
-T   template &lt;class Operation&gt;
-    class binder2nd
-      : public unary_function&lt;typename Operation::first_argument_type,
-                              typename Operation::result_type&gt; {
-    protected:
-T     Operation                       op;
-T     typename Operation::second_argument_type value;
-    public:
-V     binder2nd(const Operation&amp; x,
-                const typename Operation::second_argument_type&amp; y);
-V     typename Operation::result_type
-        operator()(const typename Operation::first_argument_type&amp; x) const;
-    };
-
-   20.3.6.4  bind2nd                                       [lib.bind.2nd]
-
-T  template &lt;class Operation, class T&gt;
-    binder2nd&lt;Operation&gt; bind2nd(const Operation&amp; op, const T&amp; x);
-
-
-   20.3.7  Adaptors for pointers to       [lib.function.pointer.adaptors]
-       functions
-
-   1 To  allow  pointers to (unary and binary) functions to work with func-
-   tion adaptors the library provides:
-
-T   template &lt;class Arg, class Result&gt;
-    class pointer_to_unary_function : public unary_function&lt;Arg, Result&gt; {
-    public:
-T     explicit pointer_to_unary_function(Result (*f)(Arg));
-V     Result operator()(Arg x) const;
-    };
-
-T  template &lt;class Arg, class Result&gt;
-    pointer_to_unary_function&lt;Arg, Result&gt; ptr_fun(Result (*f)(Arg));
-
-T       template &lt;class Arg1, class Arg2, class Result&gt;
-        class pointer_to_binary_function :
-          public binary_function&lt;Arg1,Arg2,Result&gt; {
-        public:
-T         explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
-V         Result operator()(Arg1 x, Arg2 y) const;
-        };
-
-
-   20.3.8  Adaptors for pointers to         [lib.member.pointer.adaptors]
-       members
-
-T  template &lt;class S, class T&gt; class mem_fun_t
-          : public unary_function&lt;T*, S&gt; {
-   public:
-T   explicit mem_fun_t(S (T::*p)());
-V   S operator()(T* p) const;
-   };
-
-T   template &lt;class S, class T, class A&gt; class mem_fun1_t
-          : public binary_function&lt;T*, A, S&gt; {
-    public:
-T     explicit mem_fun1_t(S (T::*p)(A));
-V     S operator()(T* p, A x) const;
-   };
-
-V   template&lt;class S, class T&gt; mem_fun_t&lt;S,T&gt;
-       mem_fun(S (T::*f)());
-V   template&lt;class S, class T, class A&gt; mem_fun1_t&lt;S,T,A&gt;
-       mem_fun(S (T::*f)(A));
-
-T   template &lt;class S, class T&gt; class mem_fun_ref_t
-          : public unary_function&lt;T, S&gt; {
-    public:
-T     explicit mem_fun_ref_t(S (T::*p)());
-V     S operator()(T&amp; p) const;
-   };
-
-T   template &lt;class S, class T, class A&gt; class mem_fun1_ref_t
-          : public binary_function&lt;T, A, S&gt; {
-    public:
-T     explicit mem_fun1_ref_t(S (T::*p)(A));
-V     S operator()(T&amp; p, A x) const;
-   };
-
-T   template&lt;class S, class T&gt; mem_fun_ref_t&lt;S,T&gt;
-       mem_fun_ref(S (T::*f)());
-
-T   template&lt;class S, class T, class A&gt; mem_fun1_ref_t&lt;S,T,A&gt;
-       mem_fun_ref(S (T::*f)(A));
-
-T  template &lt;class S, class T&gt; class const_mem_fun_t
-        : public unary_function&lt;T*, S&gt; {
-   public:
-T   explicit const_mem_fun_t(S (T::*p)() const);
-V   S operator()(const T* p) const;
-   };
-
-T  template &lt;class S, class T, class A&gt; class const_mem_fun1_t
-        : public binary_function&lt;T*, A, S&gt; {
-   public:
-T   explicit const mem_fun1_t(S (T::*p)(A) const);
-V   S operator()(const T* p, A x) const;
-   };
-
-V   template&lt;class S, class T&gt; const_mem_fun_t&lt;S,T&gt;
-       mem_fun(S (T::*f)() const);
-V   template&lt;class S, class T, class A&gt; const_mem_fun1_t&lt;S,T,A&gt;
-       mem_fun(S (T::*f)(A) const);
-
-T   template &lt;class S, class T&gt; class const_mem_fun_ref_t
-          : public unary_function&lt;T, S&gt; {
-    public:
-T     explicit const_mem_fun_ref_t(S (T::*p)() const);
-V     S operator()(const T&amp; p) const;
-   };
-
-T   template &lt;class S, class T, class A&gt; class const_mem_fun1_ref_t
-          : public binary_function&lt;T, A, S&gt; {
-    public:
-T     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
-V     S operator()(const T&amp; p, A x) const;
-   };
-
-T   template&lt;class S, class T&gt; const_mem_fun_ref_t&lt;S,T&gt;
-       mem_fun_ref(S (T::*f)() const);
-
-T   template&lt;class S, class T, class A&gt; const_mem_fun1_ref_t&lt;S,T,A&gt;
-        mem_fun_ref(S (T::*f)(A) const);
-
-   20.4  Memory                                              [lib.memory]
-
-   Header &lt;memory&gt; synopsis
-
-    // _lib.default.allocator_, the default allocator:
-T   template &lt;class T&gt; class allocator;
-T   template &lt;&gt; class allocator&lt;void&gt;;
-T   template &lt;class T, class U&gt;
-      bool operator==(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) throw();
-T   template &lt;class T, class U&gt;
-      bool operator!=(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) throw();
-    // _lib.storage.iterator_, raw storage iterator:
-T   template &lt;class OutputIterator, class T&gt; class raw_storage_iterator;
-    // _lib.temporary.buffer_, temporary buffers:
-T   template &lt;class T&gt;
-      pair&lt;T*,ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n);
-T   template &lt;class T&gt;
-      void return_temporary_buffer(T* p);
-    // _lib.specialized.algorithms_, specialized algorithms:
-T   template &lt;class InputIterator, class ForwardIterator&gt;
-      ForwardIterator
-        uninitialized_copy(InputIterator first, InputIterator last,
-                           ForwardIterator result);
-T   template &lt;class ForwardIterator, class T&gt;
-      void uninitialized_fill(ForwardIterator first, ForwardIterator last,
-                              const T&amp; x);
-T   template &lt;class ForwardIterator, class Size, class T&gt;
-      void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);
-    // _lib.auto.ptr_, pointers:
-X   template&lt;class X&gt; class auto_ptr;
-   }
-
-   20.4.1  The default allocator                  [lib.default.allocator]
-
-T   template &lt;class T&gt; class allocator;
-    // specialize for void:
-T   template &lt;&gt; class allocator&lt;void&gt; {
-    public:
-T     typedef void*       pointer;
-T     typedef const void* const_pointer;
-      // reference-to-void members are impossible.
-T     typedef void  value_type;
-T     template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
-    };
-
-T   template &lt;class T&gt; class allocator {
-     public:
-T     typedef size_t    size_type;
-T     typedef ptrdiff_t difference_type;
-T     typedef T*        pointer;
-T     typedef const T*  const_pointer;
-T     typedef T&amp;        reference;
-T     typedef const T&amp;  const_reference;
-T     typedef T         value_type;
-T     template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
-T     allocator() throw();
-T     allocator(const allocator&amp;) throw();
-T     template &lt;class U&gt; allocator(const allocator&lt;U&gt;&amp;) throw();
-T    ~allocator() throw();
-T     pointer address(reference x) const;
-T     const_pointer address(const_reference x) const;
-T     pointer allocate(
-        size_type, allocator&lt;void&gt;::const_pointer hint = 0);
-T     void deallocate(pointer p, size_type n);
-T     size_type max_size() const throw();
-T     void construct(pointer p, const T&amp; val);
-T     void destroy(pointer p);
-    };
-
-   20.4.1.2  allocator globals                    [lib.allocator.globals]
-
-T  template &lt;class T1, class T2&gt;
-    bool operator==(const allocator&lt;T1&gt;&amp;, const allocator&lt;T2&gt;&amp;) throw();
-T  template &lt;class T1, class T2&gt;
-    bool operator!=(const allocator&lt;T1&gt;&amp;, const allocator&lt;T2&gt;&amp;) throw();
-
-   20.4.2  Raw storage iterator                    [lib.storage.iterator]
-
-T   template &lt;class OutputIterator, class T&gt;
-    class raw_storage_iterator
-      : public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
-    public:
-T     explicit raw_storage_iterator(OutputIterator x);
-T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*();
-T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);
-T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++();
-T     raw_storage_iterator&lt;OutputIterator,T&gt;  operator++(int);
-    };
-
-   20.4.3  Temporary buffers                       [lib.temporary.buffer]
-
-T  template &lt;class T&gt;
-    pair&lt;T*, ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n);
-
-T  template &lt;class T&gt; void return_temporary_buffer(T* p);
-
-   20.4.4  Specialized algorithms            [lib.specialized.algorithms]
-
-   20.4.4.1  uninitialized_copy                  [lib.uninitialized.copy]
-
-V  template &lt;class InputIterator, class ForwardIterator&gt;
-    ForwardIterator
-      uninitialized_copy(InputIterator first, InputIterator last,
-                         ForwardIterator result);
-
-   20.4.4.2  uninitialized_fill                  [lib.uninitialized.fill]
-
-V  template &lt;class ForwardIterator, class T&gt;
-    void uninitialized_fill(ForwardIterator first, ForwardIterator last,
-                            const T&amp; x);
-
-   20.4.4.3  uninitialized_fill_n              [lib.uninitialized.fill.n]
-
-V  template &lt;class ForwardIterator, class Size, class T&gt;
-    void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);
-
-   20.4.5  Template class auto_ptr                         [lib.auto.ptr]
-
-X   template&lt;class X&gt; class auto_ptr {
-      template &lt;class Y&gt; struct auto_ptr_ref {};
-    public:
-T     typedef X element_type;
-      // _lib.auto.ptr.cons_ construct/copy/destroy:
-T     explicit auto_ptr(X* p =0) throw();
-T     auto_ptr(auto_ptr&amp;) throw();
-T     template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;&amp;) throw();
-T     auto_ptr&amp; operator=(auto_ptr&amp;) throw();
-T     template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt;&amp;) throw();
-T    ~auto_ptr() throw();
-      // _lib.auto.ptr.members_ members:
-T     X&amp; operator*() const throw();
-T     X* operator-&gt;() const throw();
-T     X* get() const throw();
-T     X* release() throw();
-T     void reset(X* p =0) throw();
-
-      // _lib.auto.ptr.conv_ conversions:
-X     auto_ptr(auto_ptr_ref&lt;X&gt;) throw();
-X     template&lt;class Y&gt; operator auto_ptr_ref&lt;Y&gt;() throw();
-X     template&lt;class Y&gt; operator auto_ptr&lt;Y&gt;() throw();
-    };
-
-   20.4.6  C Library                                       [lib.c.malloc]
-
-                    Table 7--Header &lt;cstdlib&gt; synopsis
-
-X                    Functions:   calloc   malloc
-                                  free     realloc
-
-
-                    Table 8--Header &lt;cstring&gt; synopsis
-
-X                    Macro:       NULL
-X                    Type:        size_t
-X                    Functions:   memchr    memcmp
-X                    memcpy       memmove   memset
-
-                     Table 9--Header &lt;ctime&gt; synopsis
-
-X          Macros:   NULL
-X          Types:    size_t   clock_t    time_t
-X          Struct:   tm
-           Functions:
-X          asctime   clock    difftime   localtime   strftime
-X          ctime     gmtime   mktime     time
-
-   21.1.1  Character traits requirements        [lib.char.traits.require]
-
-   2 The struct template
-T  template&lt;class charT&gt; struct char_traits;
-   shall be provided in the header &lt;string&gt; as a basis for  explicit spe-
-   cializations.
-
-
-   21.1.3.1  struct                [lib.char.traits.specializations.char]
-       char_traits&lt;char&gt;
-
-T   template&lt;&gt;
-    struct char_traits&lt;char&gt; {
-T     typedef char        char_type;
-T     typedef int         int_type;
-T     typedef streamoff   off_type;
-T     typedef streampos   pos_type;
-T     typedef mbstate_t   state_type;
-
-T     static void assign(char_type&amp; c1, const char_type&amp; c2);
-T     static bool eq(const char_type&amp; c1, const char_type&amp; c2);
-T     static bool lt(const char_type&amp; c1, const char_type&amp; c2);
-
-T     static int compare(const char_type* s1, const char_type* s2, size_t n);
-T     static size_t length(const char_type* s);
-T     static const char_type* find(const char_type* s, size_t n,
-                                   const char_type&amp; a);
-T     static char_type* move(char_type* s1, const char_type* s2, size_t n);
-T     static char_type* copy(char_type* s1, const char_type* s2, size_t n);
-T     static char_type* assign(char_type* s, size_t n, char_type a);
-
-T     static int_type not_eof(const int_type&amp; c);
-T     static char_type to_char_type(const int_type&amp; c);
-T     static int_type to_int_type(const char_type&amp; c);
-T     static bool eq_int_type(const int_type&amp; c1, const int_type&amp; c2);
-T     static int_type eof();
-    };
-
-   21.1.3.2  struct             [lib.char.traits.specializations.wchar.t]
-       char_traits&lt;wchar_t&gt;
-
-V   template&lt;&gt;
-    struct char_traits&lt;wchar_t&gt; {
-V     typedef wchar_t      char_type;
-V     typedef wint_t       int_type;
-V     typedef streamoff   off_type;
-V     typedef wstreampos   pos_type;
-V     typedef mbstate_t    state_type;
-
-V     static void assign(char_type&amp; c1, const char_type&amp; c2);
-V     static bool eq(const char_type&amp; c1, const char_type&amp; c2);
-V     static bool lt(const char_type&amp; c1, const char_type&amp; c2);
-
-V     static int compare(const char_type* s1, const char_type* s2, size_t n);
-V     static size_t length(const char_type* s);
-V     static const char_type* find(const char_type* s, size_t n,
-                                   const char_type&amp; a);
-V     static char_type* move(char_type* s1, const char_type* s2, size_t n);
-V     static char_type* copy(char_type* s1, const char_type* s2, size_t n);
-V     static char_type* assign(char_type* s, size_t n, char_type a);
-
-V     static int_type not_eof(const int_type&amp; c);
-V     static char_type to_char_type(const int_type&amp; c);
-V     static int_type to_int_type(const char_type&amp; c);
-V     static bool eq_int_type(const int_type&amp; c1, const int_type&amp; c2);
-V     static int_type eof();
-    };
-
-   21.2  String classes                              [lib.string.classes]
-
-    // _lib.char.traits_, character traits:
-V   template&lt;class charT&gt;
-      struct char_traits;
-V   template &lt;&gt; struct char_traits&lt;char&gt;;
-V   template &lt;&gt; struct char_traits&lt;wchar_t&gt;;
-
-    // _lib.basic.string_, basic_string:
-V   template&lt;class charT, class traits = char_traits&lt;charT&gt;,
-             class Allocator = allocator&lt;charT&gt; &gt;
-      class basic_string;
-V   template&lt;class charT, class traits, class Allocator&gt;
-      basic_string&lt;charT,traits,Allocator&gt;
-        operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                  const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      basic_string&lt;charT,traits,Allocator&gt;
-        operator+(const charT* lhs,
-                  const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      basic_string&lt;charT,traits,Allocator&gt;
-        operator+(charT lhs, const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      basic_string&lt;charT,traits,Allocator&gt;
-        operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                  const charT* rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      basic_string&lt;charT,traits,Allocator&gt;
-        operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, charT rhs);
-
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator==(const charT* lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const charT* rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator!=(const charT* lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const charT* rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const charT* rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&lt; (const charT* lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const charT* rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&gt; (const charT* lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const charT* rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&lt;=(const charT* lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                      const charT* rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-      bool operator&gt;=(const charT* lhs,
-                      const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-
-    // _lib.string.special_:
-V   template&lt;class charT, class traits, class Allocator&gt;
-       void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
-                 basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
-V   template&lt;class charT, class traits, class Allocator&gt;
-     basic_istream&lt;charT,traits&gt;&amp;
-      operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp; is,
-                 basic_string&lt;charT,traits,Allocator&gt;&amp; str);
-T   template&lt;class charT, class traits, class Allocator&gt;
-     basic_ostream&lt;charT, traits&gt;&amp;
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
-                 const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
-V   template&lt;class charT, class traits, class Allocator&gt;
-     basic_istream&lt;charT,traits&gt;&amp;
-       getline(basic_istream&lt;charT,traits&gt;&amp; is,
-               basic_string&lt;charT,traits,Allocator&gt;&amp; str,
-               charT delim);
-V   template&lt;class charT, class traits, class Allocator&gt;
-     basic_istream&lt;charT,traits&gt;&amp;
-       getline(basic_istream&lt;charT,traits&gt;&amp; is,
-               basic_string&lt;charT,traits,Allocator&gt;&amp; str);
-V   typedef basic_string&lt;char&gt; string;
-T   typedef basic_string&lt;wchar_t&gt; wstring;
-   }
-
-   21.3  Template class basic_string                   [lib.basic.string]
-
-V  namespace std {
-    template&lt;class charT, class traits = char_traits&lt;charT&gt;,
-             class Allocator = allocator&lt;charT&gt; &gt;
-    class basic_string {
-    public:
-      // types:
-      typedef          traits                     traits_type;
-      typedef typename traits::char_type          value_type;
-      typedef          Allocator                  allocator_type;
-      typedef typename Allocator::size_type       size_type;
-      typedef typename Allocator::difference_type difference_type;
-      typedef typename Allocator::reference       reference;
-      typedef typename Allocator::const_reference const_reference;
-      typedef typename Allocator::pointer         pointer;
-      typedef typename Allocator::const_pointer   const_pointer;
-      typedef implementation defined             iterator;
-      typedef implementation defined             const_iterator;
-      typedef std::reverse_iterator&lt;iterator&gt; reverse_iterator;
-      typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-      static const size_type npos = -1;
-
-      // _lib.string.cons_ construct/copy/destroy:
-V     explicit basic_string(const Allocator&amp; a = Allocator());
-V     basic_string(const basic_string&amp; str, size_type pos = 0,
-                   size_type n = npos, const Allocator&amp; a = Allocator());
-V     basic_string(const charT* s,
-                   size_type n, const Allocator&amp; a = Allocator());
-V     basic_string(const charT* s, const Allocator&amp; a = Allocator());
-V     basic_string(size_type n, charT c, const Allocator&amp; a = Allocator());
-V     template&lt;class InputIterator&gt;
-        basic_string(InputIterator begin, InputIterator end,
-                     const Allocator&amp; a = Allocator());
-V    ~basic_string();
-V     basic_string&amp; operator=(const basic_string&amp; str);
-V     basic_string&amp; operator=(const charT* s);
-V     basic_string&amp; operator=(charT c);
-      // _lib.string.iterators_ iterators:
-V     iterator       begin();
-V     const_iterator begin() const;
-V     iterator       end();
-V     const_iterator end() const;
-
-V     reverse_iterator       rbegin();
-V     const_reverse_iterator rbegin() const;
-V     reverse_iterator       rend();
-V     const_reverse_iterator rend() const;
-      // _lib.string.capacity_ capacity:
-V     size_type size() const;
-V     size_type length() const;
-V     size_type max_size() const;
-V     void resize(size_type n, charT c);
-V     void resize(size_type n);
-V     size_type capacity() const;
-V     void reserve(size_type res_arg = 0);
-V     void clear();
-V     bool empty() const;
-      // _lib.string.access_ element access:
-V     const_reference operator[](size_type pos) const;
-V     reference       operator[](size_type pos);
-V     const_reference at(size_type n) const;
-V     reference       at(size_type n);
-      // _lib.string.modifiers_ modifiers:
-V     basic_string&amp; operator+=(const basic_string&amp; str);
-V     basic_string&amp; operator+=(const charT* s);
-V     basic_string&amp; operator+=(charT c);
-V     basic_string&amp; append(const basic_string&amp; str);
-V     basic_string&amp; append(const basic_string&amp; str, size_type pos,
-                           size_type n);
-V     basic_string&amp; append(const charT* s, size_type n);
-V     basic_string&amp; append(const charT* s);
-V     basic_string&amp; append(size_type n, charT c);
-V     template&lt;class InputIterator&gt;
-        basic_string&amp; append(InputIterator first, InputIterator last);
-V     void push_back(const charT);
-
-V     basic_string&amp; assign(const basic_string&amp;);
-V     basic_string&amp; assign(const basic_string&amp; str, size_type pos,
-                           size_type n);
-V     basic_string&amp; assign(const charT* s, size_type n);
-V     basic_string&amp; assign(const charT* s);
-V     basic_string&amp; assign(size_type n, charT c);
-V     template&lt;class InputIterator&gt;
-        basic_string&amp; assign(InputIterator first, InputIterator last);
-V     basic_string&amp; insert(size_type pos1, const basic_string&amp; str);
-V     basic_string&amp; insert(size_type pos1, const basic_string&amp; str,
-                           size_type pos2, size_type n);
-V     basic_string&amp; insert(size_type pos, const charT* s, size_type n);
-V     basic_string&amp; insert(size_type pos, const charT* s);
-V     basic_string&amp; insert(size_type pos, size_type n, charT c);
-V     iterator insert(iterator p, charT c);
-V     void     insert(iterator p, size_type n, charT c);
-V     template&lt;class InputIterator&gt;
-        void insert(iterator p, InputIterator first, InputIterator last);
-V     basic_string&amp; erase(size_type pos = 0, size_type n = npos);
-V     iterator erase(iterator position);
-V     iterator erase(iterator first, iterator last);
-V     basic_string&amp; replace(size_type pos1, size_type n1,
-                            const basic_string&amp; str);
-V     basic_string&amp; replace(size_type pos1, size_type n1,
-                            const basic_string&amp; str,
-                            size_type pos2, size_type n2);
-V     basic_string&amp; replace(size_type pos, size_type n1, const charT* s,
-                            size_type n2);
-V     basic_string&amp; replace(size_type pos, size_type n1, const charT* s);
-V     basic_string&amp; replace(size_type pos, size_type n1, size_type n2,
-                            charT c);
-V     basic_string&amp; replace(iterator i1, iterator i2, const basic_string&amp; str);
-V     basic_string&amp; replace(iterator i1, iterator i2, const charT* s,
-                            size_type n);
-V     basic_string&amp; replace(iterator i1, iterator i2, const charT* s);
-V     basic_string&amp; replace(iterator i1, iterator i2,
-                            size_type n, charT c);
-V     template&lt;class InputIterator&gt;
-        basic_string&amp; replace(iterator i1, iterator i2,
-                              InputIterator j1, InputIterator j2);
-V     size_type copy(charT* s, size_type n, size_type pos = 0) const;
-V     void swap(basic_string&lt;charT,traits,Allocator&gt;&amp;);
-      // _lib.string.ops_ string operations:
-V     const charT* c_str() const;         // explicit
-V     const charT* data() const;
-V     allocator_type get_allocator() const;
-V     size_type find (const basic_string&amp; str, size_type pos = 0) const;
-V     size_type find (const charT* s, size_type pos, size_type n) const;
-V     size_type find (const charT* s, size_type pos = 0) const;
-V     size_type find (charT c, size_type pos = 0) const;
-V     size_type rfind(const basic_string&amp; str, size_type pos = npos) const;
-V     size_type rfind(const charT* s, size_type pos, size_type n) const;
-V     size_type rfind(const charT* s, size_type pos = npos) const;
-V     size_type rfind(charT c, size_type pos = npos) const;
-
-V     size_type find_first_of(const basic_string&amp; str,
-                              size_type pos = 0) const;
-V     size_type find_first_of(const charT* s,
-                              size_type pos, size_type n) const;
-V     size_type find_first_of(const charT* s, size_type pos = 0) const;
-V     size_type find_first_of(charT c, size_type pos = 0) const;
-V     size_type find_last_of (const basic_string&amp; str,
-                              size_type pos = npos) const;
-V     size_type find_last_of (const charT* s,
-                              size_type pos, size_type n) const;
-V     size_type find_last_of (const charT* s, size_type pos = npos) const;
-V     size_type find_last_of (charT c, size_type pos = npos) const;
-V     size_type find_first_not_of(const basic_string&amp; str,
-                                  size_type pos = 0) const;
-V     size_type find_first_not_of(const charT* s, size_type pos,
-                                  size_type n) const;
-V     size_type find_first_not_of(const charT* s, size_type pos = 0) const;
-V     size_type find_first_not_of(charT c, size_type pos = 0) const;
-V     size_type find_last_not_of (const basic_string&amp; str,
-                                  size_type pos = npos) const;
-V     size_type find_last_not_of (const charT* s, size_type pos,
-                                  size_type n) const;
-V     size_type find_last_not_of (const charT* s,
-                                  size_type pos = npos) const;
-V     size_type find_last_not_of (charT c, size_type pos = npos) const;
-V     basic_string substr(size_type pos = 0, size_type n = npos) const;
-V     int compare(const basic_string&amp; str) const;
-V     int compare(size_type pos1, size_type n1,
-                  const basic_string&amp; str) const;
-V     int compare(size_type pos1, size_type n1,
-                  const basic_string&amp; str,
-                  size_type pos2, size_type n2) const;
-V     int compare(const charT* s) const;
-V     int compare(size_type pos1, size_type n1,
-                  const charT* s, size_type n2 = npos) const;
-    };
-   }
-
-   21.4  Null-terminated sequence utilities               [lib.c.strings]
-
-                    Table 10--Header &lt;cctype&gt; synopsis
-
-            isalnum   isdigit   isprint   isupper    tolower
-X           isalpha   isgraph   ispunct   isxdigit   toupper
-            iscntrl   islower   isspace
-
-                   Table 11--Header &lt;cwctype&gt; synopsis
-
-X  Macro:     WEOF &lt;cwctype&gt;
-X  Types:     wctrans_t   wctype_t   wint_t &lt;cwctype&gt;
-   Functions:
-X  iswalnum   iswctype    iswlower   iswspace    towctrans   wctrans
-X  iswalpha   iswdigit    iswprint   iswupper    towlower    wctype
-X  iswcntrl   iswgraph    iswpunct   iswxdigit   towupper
-
-                   Table 12--Header &lt;cstring&gt; synopsis
-
-X           Macro:    NULL &lt;cstring&gt;
-X           Type:     size_t &lt;cstring&gt;
-            Functions:
-X           memchr    strcat    strcspn    strncpy   strtok
-X           memcmp    strchr    strerror   strpbrk   strxfrm
-X           memcpy    strcmp    strlen     strrchr
-X           memmove   strcoll   strncat    strspn
-X           memset    strcpy    strncmp    strstr
-
-                    Table 13--Header &lt;cwchar&gt; synopsis
-   Macros:    NULL &lt;cwchar&gt;   WCHAR_MAX         WCHAR_MIN   WEOF &lt;cwchar&gt;
-   Types:     mbstate_t       wint_t &lt;cwchar&gt;   size_t
-   Functions:
-X  btowc      getwchar        ungetwc           wcscpy      wcsrtombs   wmemchr
-X  fgetwc     mbrlen          vfwprintf         wcscspn     wcsspn      wmemcmp
-X  fgetws     mbrtowc         vswprintf         wcsftime    wcsstr      wmemcpy
-X  fputwc     mbsinit         vwprintf          wcslen      wcstod      wmemmove
-X  fputws     mbsrtowcs       wcrtomb           wcsncat     wcstok      wmemset
-X  fwide      putwc           wcscat            wcsncmp     wcstol      wprintf
-X  fwprintf   putwchar        wcschr            wcsncpy     wcstoul     wscanf
-X  fwscanf    swprintf        wcscmp            wcspbrk     wcsxfrm
-X  getwc      swscanf         wcscoll           wcsrchr     wctob
-
-                   Table 14--Header &lt;cstdlib&gt; synopsis
-
-               Macros:   MB_CUR_MAX
-               Functions:
-X              atol      mblen        strtod    wctomb
-X              atof      mbstowcs     strtol    wcstombs
-X              atoi      mbtowc       strtoul
-
-X  const char* strchr(const char* s, int c);
-X       char* strchr(      char* s, int c);
-
-X  const char* strpbrk(const char* s1, const char* s2);
-X       char* strpbrk(      char* s1, const char* s2);
-
-X  const char* strrchr(const char* s, int c);
-X       char* strrchr(      char* s, int c);
-
-X  const char* strstr(const char* s1, const char* s2);
-X       char* strstr(      char* s1, const char* s2);
-
-X  const void* memchr(const void* s, int c, size_t n);
-X       void* memchr(      void* s, int c, size_t n);
-
-X  const wchar_t* wcschr(const wchar_t* s, wchar_t c);
-X       wchar_t* wcschr(      wchar_t* s, wchar_t c);
-
-X  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);
-X       wchar_t* wcspbrk(      wchar_t* s1, const wchar_t* s2);
-
-X  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);
-X       wchar_t* wcsrchr(      wchar_t* s, wchar_t c);
-
-X  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);
-X       wchar_t* wcsstr(      wchar_t* s1, const wchar_t* s2);
-
-X  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);
-X       wchar_t* wmemchr(      wchar_t* s, wchar_t c, size_t n);
-
-   [for initial efforts on the above, see shadow/string.h]
-
-   22.1  Locales                                            [lib.locales]
-
-   Header &lt;locale&gt; synopsis
-
-    // _lib.locale_, locale:
-T   class locale;
-T   template &lt;class Facet&gt; const Facet&amp; use_facet(const locale&amp;);
-T   template &lt;class Facet&gt; bool         has_facet(const locale&amp;) throw();
-
-    // _lib.locale.convenience_, convenience interfaces:
-T   template &lt;class charT&gt; bool isspace (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool isprint (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool iscntrl (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool isupper (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool islower (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool isalpha (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool isdigit (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool ispunct (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool isxdigit(charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool isalnum (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; bool isgraph (charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; charT toupper(charT c, const locale&amp; loc);
-T   template &lt;class charT&gt; charT tolower(charT c, const locale&amp; loc);
-    // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype:
-    class ctype_base;
-T   template &lt;class charT&gt; class ctype;
-T   template &lt;&gt;            class ctype&lt;char&gt;;             // specialization
-S   template &lt;class charT&gt; class ctype_byname;
-S   template &lt;&gt;            class ctype_byname&lt;char&gt;;      // specialization
-T   class codecvt_base;
-X   template &lt;class internT, class externT, class stateT&gt; class codecvt;
-S   template &lt;class internT, class externT, class stateT&gt; class codecvt_byname;
-    // _lib.category.numeric_ and _lib.facet.numpunct_, numeric:
-X   template &lt;class charT, class InputIterator&gt;  class num_get;
-X   template &lt;class charT, class OutputIterator&gt; class num_put;
-T   template &lt;class charT&gt; class numpunct;
-S   template &lt;class charT&gt; class numpunct_byname;
-    // _lib.category.collate_, collation:
-T   template &lt;class charT&gt; class collate;
-S   template &lt;class charT&gt; class collate_byname;
-    // _lib.category.time_, date and time:
-T   class time_base;
-S   template &lt;class charT, class InputIterator&gt;  class time_get;
-S   template &lt;class charT, class InputIterator&gt;  class time_get_byname;
-S   template &lt;class charT, class OutputIterator&gt; class time_put;
-S   template &lt;class charT, class OutputIterator&gt; class time_put_byname;
-    // _lib.category.monetary_, money:
-T   class money_base;
-S   template &lt;class charT, class InputIterator&gt;  class money_get;
-S   template &lt;class charT, class OutputIterator&gt; class money_put;
-S   template &lt;class charT, bool Intl&gt; class moneypunct;
-S   template &lt;class charT, bool Intl&gt; class moneypunct_byname;
-    // _lib.category.messages_, message retrieval:
-T   class messages_base;
-S   template &lt;class charT&gt; class messages;
-S   template &lt;class charT&gt; class messages_byname;
-
-
-   22.1.1  Class locale                                      [lib.locale]
-
-X   class locale {
-    public:
-      // types:
-T     class facet;
-T     class id;
-T     typedef int category;
-T     static const category   // values assigned here are for exposition only
-T       none     = 0,
-T       collate  = 0x010, ctype    = 0x020,
-T       monetary = 0x040, numeric  = 0x080,
-T       time     = 0x100, messages = 0x200,
-T       all = collate | ctype | monetary | numeric | time  | messages;
-      // construct/copy/destroy:
-T     locale() throw()
-T     locale(const locale&amp; other) throw()
-X     explicit locale(const char* std_name);
-X     locale(const locale&amp; other, const char* std_name, category);
-T     template &lt;class Facet&gt; locale(const locale&amp; other, Facet* f);
-T     locale(const locale&amp; other, const locale&amp; one, category);
-T    ~locale() throw();           // non-virtual
-T     const locale&amp; operator=(const locale&amp; other) throw();
-T     template &lt;class Facet&gt; locale combine(const locale&amp; other) const;
-      // locale operations:
-X     basic_string&lt;char&gt;                  name() const;
-T     bool operator==(const locale&amp; other) const;
-T     bool operator!=(const locale&amp; other) const;
-T     template &lt;class charT, class Traits, class Allocator&gt;
-        bool operator()(const basic_string&lt;charT,Traits,Allocator&gt;&amp; s1,
-                        const basic_string&lt;charT,Traits,Allocator&gt;&amp; s2) const;
-      // global locale objects:
-T     static       locale  global(const locale&amp;);
-T     static const locale&amp; classic();
-    };
-
-   22.1.1.1  locale types                              [lib.locale.types]
-
-   22.1.1.1.1  Type locale::category                [lib.locale.category]
-
-T  typedef int category;
-
-T   none, collate, ctype, monetary, numeric, time, and messages
-
-      [required locale members]
-T     collate&lt;char&gt;, collate&lt;wchar_t&gt;
-T     ctype&lt;char&gt;, ctype&lt;wchar_t&gt;
-T     codecvt&lt;char,char,mbstate_t&gt;,
-S     codecvt&lt;wchar_t,char,mbstate_t&gt;
-T     moneypunct&lt;char&gt;, moneypunct&lt;wchar_t&gt;
-T     moneypunct&lt;char,true&gt;, moneypunct&lt;wchar_t,true&gt;,
-S     money_get&lt;char&gt;, money_get&lt;wchar_t
-S     money_put&lt;char&gt;, money_put&lt;wchar_t&gt;
-T     numpunct&lt;char&gt;, numpunct&lt;wchar_t&gt;,
-X     num_get&lt;char&gt;, num_get&lt;wchar_t&gt;
-X     num_put&lt;char&gt;, num_put&lt;wchar_t&gt;
-S     time_get&lt;char&gt;, time_get&lt;wchar_t&gt;,
-S     time_put&lt;char&gt;, time_put&lt;wchar_t&gt;
-S     messages&lt;char&gt;, messages&lt;wchar_t&gt;
-
-      [required instantiations]
-S    collate_byname&lt;char&gt;, collate_byname&lt;wchar_t&gt;
-S    ctype_byname&lt;char&gt;, ctype_byname&lt;wchar_t&gt;
-S    codecvt_byname&lt;char,char,mbstate_t&gt;,
-S    codecvt_byname&lt;wchar_t,char,mbstate_t&gt;
-S    moneypunct_byname&lt;char,International&gt;,
-S    moneypunct_byname&lt;wchar_t,International&gt;,
-S    money_get&lt;C,InputIterator&gt;,
-S    money_put&lt;C,OutputIterator&gt;
-S    numpunct_byname&lt;char&gt;, numpunct_byname&lt;wchar_t&gt;
-X    num_get&lt;C,InputIterator&gt;, num_put&lt;C,OutputIterator&gt;
-S    time_get&lt;char,InputIterator&gt;,
-S    time_get_byname&lt;char,InputIterator&gt;,
-S    time_get&lt;wchar_t,OutputIterator&gt;,
-S    time_get_byname&lt;wchar_t,OutputIterator&gt;,
-S    time_put&lt;char,OutputIterator&gt;,
-S    time_put_byname&lt;char,OutputIterator&gt;,
-S    time_put&lt;wchar_t,OutputIterator&gt;
-S    time_put_byname&lt;wchar_t,OutputIterator&gt;
-S    messages_byname&lt;char&gt;, messages_byname&lt;wchar_t&gt;
-
-
-   22.1.1.1.2  Class locale::facet                     [lib.locale.facet]
-
-T   class locale::facet {
-    protected:
-T     explicit facet(size_t refs = 0);
-T     virtual ~facet();
-    private:
-T     facet(const facet&amp;);                // not defined
-T     void operator=(const facet&amp;);       // not defined
-    };
-   }
-
-
-   22.1.1.1.3  Class locale::id                           [lib.locale.id]
-
-T   class locale::id {
-    public:
-T     id();
-    private:
-T     void operator=(const id&amp;);  // not defined
-T     id(const id&amp;);              // not defined
-    };
-   }
-
-
-   22.2.1  The ctype category                        [lib.category.ctype]
-
-T   class ctype_base {
-    public:
-T     enum mask {         // numeric values are for exposition only.
-T       space=, print=, cntrl=, upper=, lower=,
-T       alpha=, digit=, punct=, xdigit=,
-T       alnum=, graph=
-      };
-    };
-
-
-   22.2.1.1  Template class ctype                      [lib.locale.ctype]
-
-T   template &lt;class charT&gt;
-    class ctype : public locale::facet, public ctype_base {
-    public:
-T     typedef charT char_type;
-T     explicit ctype(size_t refs = 0);
-T     bool         is(mask m, charT c) const;
-T     const charT* is(const charT* low, const charT* high, mask* vec) const;
-T     const charT* scan_is(mask m,
-                           const charT* low, const charT* high) const;
-T     const charT* scan_not(mask m,
-                            const charT* low, const charT* high) const;
-T     charT        toupper(charT c) const;
-T     const charT* toupper(charT* low, const charT* high) const;
-T     charT        tolower(charT c) const;
-T     const charT* tolower(charT* low, const charT* high) const;
-T     charT        widen(char c) const;
-T     const char*  widen(const char* low, const char* high, charT* to) const;
-T     char         narrow(charT c, char dfault) const;
-T     const charT* narrow(const charT* low, const charT*, char dfault,
-                          char* to) const;
-T     static locale::id id;
-
-    protected:
-T    ~ctype();                    // virtual
-T     virtual bool         do_is(mask m, charT c) const;
-T     virtual const charT* do_is(const charT* low, const charT* high,
-                                 mask* vec) const;
-T     virtual const charT* do_scan_is(mask m,
-                              const charT* low, const charT* high) const;
-T     virtual const charT* do_scan_not(mask m,
-                              const charT* low, const charT* high) const;
-T     virtual charT        do_toupper(charT) const;
-T     virtual const charT* do_toupper(charT* low, const charT* high) const;
-T     virtual charT        do_tolower(charT) const;
-T     virtual const charT* do_tolower(charT* low, const charT* high) const;
-T     virtual charT        do_widen(char) const;
-T     virtual const char*  do_widen(const char* low, const char* high,
-                                    charT* dest) const;
-T     virtual char         do_narrow(charT, char dfault) const;
-T     virtual const charT* do_narrow(const charT* low, const charT* high,
-                                     char dfault, char* dest) const;
-    };
-
-
-   22.2.1.2  Template class ctype_byname        [lib.locale.ctype.byname]
-
-X   template &lt;class charT&gt;
-    class ctype_byname : public ctype&lt;charT&gt; {
-    public:
-T     typedef ctype&lt;charT&gt;::mask mask;
-S     explicit ctype_byname(const char*, size_t refs = 0);
-    protected:
-S    ~ctype_byname();             // virtual
-S     virtual bool         do_is(mask m, charT c) const;
-S     virtual const charT* do_is(const charT* low, const charT* high,
-                                 mask* vec) const;
-S     virtual const char*  do_scan_is(mask m,
-                               const charT* low, const charT* high) const;
-S     virtual const char*  do_scan_not(mask m,
-                               const charT* low, const charT* high) const;
-S     virtual charT        do_toupper(charT) const;
-S     virtual const charT* do_toupper(charT* low, const charT* high) const;
-S     virtual charT        do_tolower(charT) const;
-S     virtual const charT* do_tolower(charT* low, const charT* high) const;
-S     virtual charT        do_widen(char) const;
-S     virtual const char*  do_widen(const char* low, const char* high,
-                                    charT* dest) const;
-S     virtual char         do_narrow(charT, char dfault) const;
-S     virtual const charT* do_narrow(const charT* low, const charT* high,
-                                     char dfault, char* dest) const;
-    };
-
-   22.2.1.3  ctype specializations              [lib.facet.ctype.special]
-
-T   template &lt;&gt; class ctype&lt;char&gt;
-      : public locale::facet, public ctype_base {
-    public:
-T     typedef char char_type;
-T     explicit ctype(const mask* tab = 0, bool del = false,
-                     size_t refs = 0);
-T     bool is(mask m, char c) const;
-T     const char* is(const char* low, const char* high, mask* vec) const;
-T     const char* scan_is (mask m,
-                           const char* low, const char* high) const;
-T     const char* scan_not(mask m,
-                           const char* low, const char* high) const;
-T     char        toupper(char c) const;
-T     const char* toupper(char* low, const char* high) const;
-T     char        tolower(char c) const;
-T     const char* tolower(char* low, const char* high) const;
-T     char  widen(char c) const;
-T     const char* widen(const char* low, const char* high, char* to) const;
-T     char  narrow(char c, char dfault) const;
-T     const char* narrow(const char* low, const char* high, char dfault,
-                         char* to) const;
-T     static locale::id id;
-T     static const size_t table_size = IMPLEMENTATION_DEFINED;
-
-    protected:
-T     const mask* table() const throw();
-T     static const mask* classic_table() throw();
-T    ~ctype();                    // virtual
-T     virtual char        do_toupper(char c) const;
-T     virtual const char* do_toupper(char* low, const char* high) const;
-T     virtual char        do_tolower(char c) const;
-T     virtual const char* do_tolower(char* low, const char* high) const;
-
-T     virtual char        do_widen(char c) const;
-T     virtual const char* do_widen(const char* low,
-                                   const char* high,
-                                   char* to) const;
-T     virtual char        do_narrow(char c, char dfault) const;
-T     virtual const char* do_narrow(const char* low,
-                                    const char* high,
-                                    char dfault, char* to) const;
-    };
-
-
-   22.2.1.4  Class                      [lib.locale.ctype.byname.special]
-       ctype_byname&lt;char&gt;
-
-X   template &lt;&gt; class ctype_byname&lt;char&gt; : public ctype&lt;char&gt; {
-    public:
-S     explicit ctype_byname(const char*, size_t refs = 0);
-    protected:
-S    ~ctype_byname();             // virtual
-S     virtual char        do_toupper(char c) const;
-S     virtual const char* do_toupper(char* low, const char* high) const;
-S     virtual char        do_tolower(char c) const;
-S     virtual const char* do_tolower(char* low, const char* high) const;
-
-S     virtual char        do_widen(char c) const;
-S     virtual const char* do_widen(char* low,
-                                   const char* high,
-                                   char* to) const;
-S     virtual char        do_widen(char c) const;
-S     virtual const char* do_widen(char* low, const char* high) const;
-
-    };
-
-
-
-   22.2.1.5  Template class codecvt                  [lib.locale.codecvt]
-
-T  class codecvt_base {
-   public:
-T   enum result { ok, partial, error, noconv };
-   };
-
-T  template &lt;class internT, class externT, class stateT&gt;
-   class codecvt : public locale::facet, public codecvt_base {
-   public:
-T   typedef internT  intern_type;
-T   typedef externT  extern_type;
-T   typedef stateT state_type;
-T   explicit codecvt(size_t refs = 0)
-T   result out(stateT&amp; state,
-     const internT* from, const internT* from_end, const internT*&amp; from_next,
-           externT*   to,       externT* to_limit, externT*&amp; to_next) const;
-T   result unshift(stateT&amp; state,
-           externT*   to,        externT* to_limit, externT*&amp; to_next) const;
-T   result in(stateT&amp; state,
-     const externT* from, const externT* from_end, const externT*&amp; from_next,
-           internT*   to,       internT* to_limit, internT*&amp; to_next) const;
-T   int encoding() const throw();
-T   bool always_noconv() const throw();
-T   int length(const stateT&amp;, const externT* from, const externT* end,
-               size_t max) const;
-T   int max_length() const throw();
-T   static locale::id id;
-
-   protected:
-T   ~codecvt();                   // virtual
-T   virtual result do_out(stateT&amp; state,
-     const internT* from, const internT* from_end, const internT*&amp; from_next,
-           externT* to,         externT* to_limit, externT*&amp; to_next) const;
-T   virtual result do_in(stateT&amp; state,
-T    const externT* from, const externT* from_end, const externT*&amp; from_next,
-           internT* to,         internT* to_limit, internT*&amp; to_next) const;
-T   virtual result do_unshift(stateT&amp; state,
-           externT* to,         externT* to_limit, externT*&amp; to_next) const;
-T   virtual int do_encoding() const throw();
-T   virtual bool do_always_noconv() const throw();
-T   virtual int do_length(const stateT&amp;, const externT* from,
-                          const externT* end, size_t max) const;
-T   virtual int do_max_length() const throw();
-   };
-   }
-
-
-   22.2.1.6  Template class                   [lib.locale.codecvt.byname]
-       codecvt_byname
-
-X  template &lt;class internT, class externT, class stateT&gt;
-   class codecvt_byname : public codecvt&lt;internT, externT, stateT&gt; {
-   public:
-S   explicit codecvt_byname(const char*, size_t refs = 0);
-   protected:
-S  ~codecvt_byname();             // virtual
-S   virtual result do_out(stateT&amp; state,
-      const internT* from, const internT* from_end, const internT*&amp; from_next,
-            externT* to,         externT* to_limit, externT*&amp; to_next) const;
-S   virtual result do_in(stateT&amp; state,
-      const externT* from, const externT* from_end, const externT*&amp; from_next,
-            internT* to,         internT* to_limit, internT*&amp; to_next) const;
-S   virtual result do_unshift(stateT&amp; state,
-            externT* to,         externT* to_limit, externT*&amp; to_next) const;
-S   virtual int do_encoding() const throw();
-S   virtual bool do_always_noconv() const throw();
-S   virtual int do_length(const stateT&amp;, const externT* from,
-                          const externT* end, size_t max) const;
-S   virtual result do_unshift(stateT&amp; state,
-           externT* to, externT* to_limit, externT*&amp; to_next) const;
-S   virtual int do_max_length() const throw();
-    };
-
-
-   22.2.2.1  Template class num_get                  [lib.locale.num.get]
-
-X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
-    class num_get : public locale::facet {
-    public:
-T     typedef charT            char_type;
-T     typedef InputIterator    iter_type;
-T     explicit num_get(size_t refs = 0);
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, bool&amp; v)           const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp; ,
-                    ios_base::iostate&amp; err, long&amp; v)           const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, unsigned short&amp; v) const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, unsigned int&amp; v)   const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, unsigned long&amp; v)  const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, float&amp; v)          const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, double&amp; v)         const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, long double&amp; v)    const;
-T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
-                    ios_base::iostate&amp; err, void*&amp; v)          const;
-T     static locale::id id;
-
-    protected:
-T    ~num_get();                  // virtual
-T     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, bool&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, long&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, unsigned short&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, unsigned int&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, unsigned long&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, float&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, double&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, long double&amp; v) const;
-S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
-          ios_base::iostate&amp; err, void*&amp; v) const;
-    };
-
-
-
-   22.2.2.2  Template class num_put                   [lib.locale.nm.put]
-
-X   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
-    class num_put : public locale::facet {
-    public:
-T     typedef charT            char_type;
-T     typedef OutputIterator   iter_type;
-T     explicit num_put(size_t refs = 0);
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill, bool v) const;
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill, long v) const;
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
-                    unsigned long v) const;
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
-                    double v) const;
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
-                    long double v) const;
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
-                    const void* v) const;
-T     static locale::id id;
-    protected:
-T    ~num_put();                  // virtual
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
-                               bool v) const;
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
-                               long v) const;
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
-                               unsigned long) const;
-S     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
-                               double v) const;
-S     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
-                               long double v) const;
-T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
-                               const void* v) const;
-    };
-   }
-
-   22.2.3.1  Template class numpunct                [lib.locale.numpunct]
-
-T   template &lt;class charT&gt;
-    class numpunct : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef basic_string&lt;charT&gt; string_type;
-T     explicit numpunct(size_t refs = 0);
-T     char_type    decimal_point()   const;
-T     char_type    thousands_sep()   const;
-T     string       grouping()        const;
-T     string_type  truename()        const;
-T     string_type  falsename()       const;
-T     static locale::id id;
-    protected:
-T    ~numpunct();                 // virtual
-T     virtual char_type    do_decimal_point() const;
-T     virtual char_type    do_thousands_sep() const;
-T     virtual string       do_grouping()      const;
-T     virtual string_type  do_truename()      const;      // for bool
-T     virtual string_type  do_falsename()     const;      // for bool
-    };
-   }
-
-
-
-   22.2.3.2  Template class                  [lib.locale.numpunct.byname]
-       numpunct_byname
-
-X   template &lt;class charT&gt;
-    class numpunct_byname : public numpunct&lt;charT&gt; {
-   // this class is specialized for char and wchar_t.
-    public:
-T     typedef charT                char_type;
-T     typedef basic_string&lt;charT&gt;  string_type;
-S     explicit numpunct_byname(const char*, size_t refs = 0);
-    protected:
-S    ~numpunct_byname();          // virtual
-S     virtual char_type    do_decimal_point() const;
-S     virtual char_type    do_thousands_sep() const;
-S     virtual string       do_grouping()      const;
-S     virtual string_type  do_truename()      const;      // for bool
-S     virtual string_type  do_falsename()     const;      // for bool
-    };
-
-
-   22.2.4.1  Template class collate                  [lib.locale.collate]
-
-T   template &lt;class charT&gt;
-    class collate : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef basic_string&lt;charT&gt; string_type;
-T     explicit collate(size_t refs = 0);
-T     int compare(const charT* low1, const charT* high1,
-                  const charT* low2, const charT* high2) const;
-T     string_type transform(const charT* low, const charT* high) const;
-T     long hash(const charT* low, const charT* high) const;
-T     static locale::id id;
-    protected:
-T    ~collate();                  // virtual
-T     virtual int    do_compare(const charT* low1, const charT* high1,
-                                const charT* low2, const charT* high2) const;
-T     virtual string_type do_transform
-                               (const charT* low, const charT* high) const;
-T     virtual long   do_hash   (const charT* low, const charT* high) const;
-    };
-
-
-   22.2.4.2  Template class                   [lib.locale.collate.byname]
-       collate_byname
-
-X   template &lt;class charT&gt;
-    class collate_byname : public collate&lt;charT&gt; {
-    public:
-T     typedef basic_string&lt;charT&gt; string_type;
-T     explicit collate_byname(const char*, size_t refs = 0);
-    protected:
-S    ~collate_byname();           // virtual
-S     virtual int    do_compare(const charT* low1, const charT* high1,
-                                const charT* low2, const charT* high2) const;
-S     virtual string_type do_transform
-                               (const charT* low, const charT* high) const;
-S     virtual long   do_hash   (const charT* low, const charT* high) const;
-    };
-
-
-   22.2.5.1  Template class time_get                [lib.locale.time.get]
-
-T   class time_base {
-    public:
-T     enum dateorder { no_order, dmy, mdy, ymd, ydm };
-    };
-
-    [Note: semantics of time_get members are implementation-defined.
-     To complete implementation requires documenting behavior.]
-
-X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
-    class time_get : public locale::facet, public time_base {
-    public:
-T     typedef charT            char_type;
-T     typedef InputIterator    iter_type;
-T     explicit time_get(size_t refs = 0);
-
-T     dateorder date_order()  const { return do_date_order(); }
-T     iter_type get_time(iter_type s, iter_type end, ios_base&amp; f,
-                         ios_base::iostate&amp; err, tm* t)  const;
-T     iter_type get_date(iter_type s, iter_type end, ios_base&amp; f,
-                         ios_base::iostate&amp; err, tm* t)  const;
-T     iter_type get_weekday(iter_type s, iter_type end, ios_base&amp; f,
-                            ios_base::iostate&amp; err, tm* t) const;
-T     iter_type get_monthname(iter_type s, iter_type end, ios_base&amp; f,
-                              ios_base::iostate&amp; err, tm* t) const;
-T     iter_type get_year(iter_type s, iter_type end, ios_base&amp; f,
-                         ios_base::iostate&amp; err, tm* t) const;
-T     static locale::id id;
-    protected:
-     ~time_get();                 // virtual
-X     virtual dateorder do_date_order()  const;
-S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&amp;,
-                                    ios_base::iostate&amp; err, tm* t) const;
-S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&amp;,
-                                    ios_base::iostate&amp; err, tm* t) const;
-S     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&amp;,
-                                       ios_base::iostate&amp; err, tm* t) const;
-S     virtual iter_type do_get_monthname(iter_type s, ios_base&amp;,
-                                         ios_base::iostate&amp; err, tm* t) const;
-S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&amp;,
-                                    ios_base::iostate&amp; err, tm* t) const;
-    };
-
-
-
-   22.2.5.2  Template class                  [lib.locale.time.get.byname]
-       time_get_byname
-
-X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
-    class time_get_byname : public time_get&lt;charT, InputIterator&gt; {
-    public:
-T     typedef time_base::dateorder dateorder;
-T     typedef InputIterator        iter_type
-
-S     explicit time_get_byname(const char*, size_t refs = 0);
-    protected:
-S    ~time_get_byname();          // virtual
-S     virtual dateorder do_date_order()  const;
-S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&amp;,
-                                    ios_base::iostate&amp; err, tm* t) const;
-S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&amp;,
-                                    ios_base::iostate&amp; err, tm* t) const;
-T     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&amp;,
-                                       ios_base::iostate&amp; err, tm* t) const;
-T     virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&amp;,
-                                         ios_base::iostate&amp; err, tm* t) const;
-S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&amp;,
-                                    ios_base::iostate&amp; err, tm* t) const;
-    };
-   }
-
-   22.2.5.3  Template class time_put                [lib.locale.time.put]
-
-X   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
-    class time_put : public locale::facet {
-    public:
-T     typedef charT            char_type;
-T     typedef OutputIterator   iter_type;
-T     explicit time_put(size_t refs = 0);
-      // the following is implemented in terms of other member functions.
-S     iter_type put(iter_type s, ios_base&amp; f, char_type fill, const tm* tmb,
-                    const charT* pattern, const charT* pat_end) const;
-T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
-                    const tm* tmb, char format, char modifier = 0) const;
-T     static locale::id id;
-    protected:
-T    ~time_put();                 // virtual
-S     virtual iter_type do_put(iter_type s, ios_base&amp;, char_type, const tm* t,
-                               char format, char modifier) const;
-    };
-
-
-
-   22.2.5.4  Template class                  [lib.locale.time.put.byname]
-       time_put_byname
-
-T   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
-    class time_put_byname : public time_put&lt;charT, OutputIterator&gt;
-    {
-    public:
-T     typedef charT          char_type;
-T     typedef OutputIterator iter_type;
-
-T     explicit time_put_byname(const char*, size_t refs = 0);
-    protected:
-T    ~time_put_byname();          // virtual
-S     virtual iter_type do_put(iter_type s, ios_base&amp;, char_type, const tm* t,
-                               char format, char modifier) const;
-    };
-
-
-   22.2.6.1  Template class money_get              [lib.locale.money.get]
-
-X   template &lt;class charT,
-              class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
-    class money_get : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef InputIterator       iter_type;
-T     typedef basic_string&lt;charT&gt; string_type;
-T     explicit money_get(size_t refs = 0);
-T     iter_type get(iter_type s, iter_type end, bool intl,
-                    ios_base&amp; f, ios_base::iostate&amp; err,
-                    long double&amp; units) const;
-T     iter_type get(iter_type s, iter_type end, bool intl,
-                    ios_base&amp; f, ios_base::iostate&amp; err,
-                    string_type&amp; digits) const;
-T     static locale::id id;
-    protected:
-T    ~money_get();                // virtual
-S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&amp;,
-                       ios_base::iostate&amp; err, long double&amp; units) const;
-S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&amp;,
-                       ios_base::iostate&amp; err, string_type&amp; digits) const;
-    };
-
-   22.2.6.2  Template class money_put              [lib.locale.money.put]
-
-X   template &lt;class charT,
-              class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
-    class money_put : public locale::facet {
-    public:
-T     typedef charT               char_type;
-T     typedef OutputIterator      iter_type;
-T     typedef basic_string&lt;charT&gt; string_type;
-T     explicit money_put(size_t refs = 0);
-T     iter_type put(iter_type s, bool intl, ios_base&amp; f,
-                    char_type fill, long double units) const;
-T     iter_type put(iter_type s, bool intl, ios_base&amp; f,
-                    char_type fill, const string_type&amp; digits) const;
-T     static locale::id id;
-
-    protected:
-T    ~money_put();                // virtual
-S     virtual iter_type
-        do_put(iter_type, bool, ios_base&amp;, char_type fill,
-               long double units) const;
-S     virtual iter_type
-        do_put(iter_type, bool, ios_base&amp;, char_type fill,
-               const string_type&amp; digits) const;
-    };
-
-
-   22.2.6.3  Template class moneypunct            [lib.locale.moneypunct]
-
-T   class money_base {
-    public:
-T     enum part { none, space, symbol, sign, value };
-T     struct pattern { char field[4]; };
-    };
-
-X   template &lt;class charT, bool International = false&gt;
-    class moneypunct : public locale::facet, public money_base {
-    public:
-T     typedef charT char_type;
-T     typedef basic_string&lt;charT&gt; string_type;
-T     explicit moneypunct(size_t refs = 0);
-T     charT        decimal_point() const;
-T     charT        thousands_sep() const;
-T     string       grouping()      const;
-T     string_type  curr_symbol()   const;
-T     string_type  positive_sign() const;
-T     string_type  negative_sign() const;
-T     int          frac_digits()   const;
-T     pattern      pos_format()    const;
-T     pattern      neg_format()    const;
-T     static locale::id id;
-T     static const bool intl = International;
-    protected:
-T    ~moneypunct();               // virtual
-S     virtual charT        do_decimal_point() const;
-S     virtual charT        do_thousands_sep() const;
-S     virtual string       do_grouping()      const;
-S     virtual string_type  do_curr_symbol()   const;
-S     virtual string_type  do_positive_sign() const;
-S     virtual string_type  do_negative_sign() const;
-S     virtual int          do_frac_digits()   const;
-T     virtual pattern      do_pos_format()    const;
-T     virtual pattern      do_neg_format()    const;
-    };
-   }
-
-   22.2.6.4  Template class                [lib.locale.moneypunct.byname]
-       moneypunct_byname
-
-X   template &lt;class charT, bool Intl = false&gt;
-    class moneypunct_byname : public moneypunct&lt;charT, Intl&gt; {
-    public:
-T     typedef money_base::pattern pattern;
-T     typedef basic_string&lt;charT&gt; string_type;
-
-T     explicit moneypunct_byname(const char*, size_t refs = 0);
-    protected:
-T    ~moneypunct_byname();        // virtual
-S     virtual charT        do_decimal_point() const;
-S     virtual charT        do_thousands_sep() const;
-S     virtual string       do_grouping()      const;
-S     virtual string_type  do_curr_symbol()   const;
-S     virtual string_type  do_positive_sign() const;
-S     virtual string_type  do_negative_sign() const;
-S     virtual int          do_frac_digits()   const;
-S     virtual pattern      do_pos_format()    const;
-S     virtual pattern      do_neg_format()    const;
-    };
-
-   22.2.7.1  Template class messages                [lib.locale.messages]
-
-T   class messages_base {
-    public:
-T     typedef int catalog;
-    };
-
-X   template &lt;class charT&gt;
-    class messages : public locale::facet, public messages_base {
-    public:
-T     typedef charT char_type;
-T     typedef basic_string&lt;charT&gt; string_type;
-T     explicit messages(size_t refs = 0);
-T     catalog open(const basic_string&lt;char&gt;&amp; fn, const locale&amp;) const;
-T     string_type  get(catalog c, int set, int msgid,
-                       const string_type&amp; dfault) const;
-T     void    close(catalog c) const;
-T     static locale::id id;
-    protected:
-T    ~messages();                 // virtual
-S     virtual catalog do_open(const basic_string&lt;char&gt;&amp;, const locale&amp;) const;
-S     virtual string_type  do_get(catalog, int set, int msgid,
-                             const string_type&amp; dfault) const;
-S     virtual void    do_close(catalog) const;
-    };
-
-   22.2.7.2  Template class                  [lib.locale.messages.byname]
-       messages_byname
-
-
-X   template &lt;class charT&gt;
-    class messages_byname : public messages&lt;charT&gt; {
-    public:
-T     typedef messages_base::catalog catalog;
-T     typedef basic_string&lt;charT&gt;    string_type;
-
-T     explicit messages_byname(const char*, size_t refs = 0);
-    protected:
-T    ~messages_byname();          // virtual
-S     virtual catalog do_open(const basic_string&lt;char&gt;&amp;, const locale&amp;) const;
-S     virtual string_type  do_get(catalog, int set, int msgid,
-                             const string_type&amp; dfault) const;
-S     virtual void    do_close(catalog) const;
-    };
-
-
-   22.3  C Library Locales                                [lib.c.locales]
-
-
-                   Table 13--Header &lt;clocale&gt; synopsis
-            Macros:
-X                        LC_ALL        LC_COLLATE   LC_CTYPE
-X                        LC_MONETARY   LC_NUMERIC   LC_TIME
-X                        NULL
-X           Struct:      lconv
-X           Functions:   localeconv    setlocale
-
-
-   23.2  Sequences                                        [lib.sequences]
-
-   &lt;deque&gt;, &lt;list&gt;, &lt;queue&gt;, &lt;stack&gt;, and &lt;vector&gt;.
-
-   Header &lt;deque&gt; synopsis
-
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class deque;
-T   template &lt;class T, class Allocator&gt;
-      bool operator==(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt; (const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator!=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt; (const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt;=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt;=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
-   }
-
-   Header &lt;list&gt; synopsis
-
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class list;
-T   template &lt;class T, class Allocator&gt;
-      bool operator==(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator!=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
-   }
-
-   Header &lt;queue&gt; synopsis
-
-   namespace std {
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt; class queue;
-T   template &lt;class T, class Container&gt;
-      bool operator==(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt; (const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator!=(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt; (const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container = vector&lt;T&gt;,
-              class Compare = less&lt;typename Container::value_type&gt; &gt;
-T   class priority_queue;
-   }
-
-   Header &lt;stack&gt; synopsis
-
-   namespace std {
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt; class stack;
-T   template &lt;class T, class Container&gt;
-      bool operator==(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt; (const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator!=(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt; (const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-   }
-
-   Header &lt;vector&gt; synopsis
-
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class vector;
-
-T   template &lt;class T, class Allocator&gt;
-      bool operator==(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt; (const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator!=(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt; (const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt;=(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt;=(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
-
-T   template &lt;class Allocator&gt; class vector&lt;bool,Allocator&gt;;
-T   template &lt;class Allocator&gt;
-      bool operator==(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&lt; (const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator!=(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&gt; (const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&gt;=(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&lt;=(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      void swap(vector&lt;bool,Allocator&gt;&amp; x, vector&lt;bool,Allocator&gt;&amp; y);
-   }
-
-   23.2.1  Template class deque                               [lib.deque]
-
-    template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
-T   class deque {
-    public:
-      // types:
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef T                                     value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-      // _lib.deque.cons_ construct/copy/destroy:
-T     explicit deque(const Allocator&amp; = Allocator());
-T     explicit deque(size_type n, const T&amp; value = T(),
-          const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        deque(InputIterator first, InputIterator last,
-              const Allocator&amp; = Allocator());
-T     deque(const deque&lt;T,Allocator&gt;&amp; x);
-T    ~deque();
-T     deque&lt;T,Allocator&gt;&amp; operator=(const deque&lt;T,Allocator&gt;&amp; x);
-T     template &lt;class InputIterator&gt;
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T&amp; t);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // _lib.deque.capacity_ capacity:
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, T c = T());
-T     bool      empty() const;
-
-      // element access:
-T     reference       operator[](size_type n);
-T     const_reference operator[](size_type n) const;
-T     reference       at(size_type n);
-T     const_reference at(size_type n) const;
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // _lib.deque.modifiers_ modifiers:
-T     void push_front(const T&amp; x);
-T     void push_back(const T&amp; x);
-T     iterator insert(iterator position, const T&amp; x);
-T     void     insert(iterator position, size_type n, const T&amp; x);
-T     template &lt;class InputIterator&gt;
-        void insert (iterator position,
-                     InputIterator first, InputIterator last);
-T     void pop_front();
-T     void pop_back();
-T     iterator erase(iterator position);
-T     iterator erase(iterator first, iterator last);
-T     void     swap(deque&lt;T,Allocator&gt;&amp;);
-T     void     clear();
-    };
-T   template &lt;class T, class Allocator&gt;
-      bool operator==(const deque&lt;T,Allocator&gt;&amp; x,
-                      const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt; (const deque&lt;T,Allocator&gt;&amp; x,
-                      const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator!=(const deque&lt;T,Allocator&gt;&amp; x,
-                      const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt; (const deque&lt;T,Allocator&gt;&amp; x,
-                      const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt;=(const deque&lt;T,Allocator&gt;&amp; x,
-                      const deque&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt;=(const deque&lt;T,Allocator&gt;&amp; x,
-                      const deque&lt;T,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class T, class Allocator&gt;
-      void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
-
-
-   23.2.2  Template class list                                 [lib.list]
-
-T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
-    class list {
-    public:
-      // types:
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef T                                     value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-
-      // _lib.list.cons_ construct/copy/destroy:
-T     explicit list(const Allocator&amp; = Allocator());
-T     explicit list(size_type n, const T&amp; value = T(),
-                    const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        list(InputIterator first, InputIterator last,
-             const Allocator&amp; = Allocator());
-T     list(const list&lt;T,Allocator&gt;&amp; x);
-T    ~list();
-T     list&lt;T,Allocator&gt;&amp; operator=(const list&lt;T,Allocator&gt;&amp; x);
-T     template &lt;class InputIterator&gt;
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T&amp; t);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // _lib.list.capacity_ capacity:
-T     bool      empty() const;
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, T c = T());
-      // element access:
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // _lib.list.modifiers_ modifiers:
-T     void push_front(const T&amp; x);
-T     void pop_front();
-T     void push_back(const T&amp; x);
-T     void pop_back();
-T     iterator insert(iterator position, const T&amp; x);
-T     void     insert(iterator position, size_type n, const T&amp; x);
-T     template &lt;class InputIterator&gt;
-        void insert(iterator position, InputIterator first,
-                    InputIterator last);
-T     iterator erase(iterator position);
-T     iterator erase(iterator position, iterator last);
-T     void     swap(list&lt;T,Allocator&gt;&amp;);
-T     void     clear();
-      // _lib.list.ops_ list operations:
-T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x);
-T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x, iterator i);
-T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x, iterator first,
-                  iterator last);
-T     void remove(const T&amp; value);
-T     template &lt;class Predicate&gt; void remove_if(Predicate pred);
-
-T     void unique();
-T     template &lt;class BinaryPredicate&gt;
-        void unique(BinaryPredicate binary_pred);
-T     void merge(list&lt;T,Allocator&gt;&amp; x);
-T     template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp; x, Compare comp);
-        void sort();
-T     template &lt;class Compare&gt; void sort(Compare comp);
-        void reverse();
-    };
-T   template &lt;class T, class Allocator&gt;
-      bool operator==(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator!=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class T, class Allocator&gt;
-      void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
-
-
-   23.2.3.1  Template class queue                             [lib.queue]
-
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt;
-    class queue {
-    public:
-T     typedef typename Container::value_type            value_type;
-T     typedef typename Container::size_type             size_type;
-T     typedef          Container                        container_type;
-    protected:
-T     Container c;
-    public:
-T     explicit queue(const Container&amp; = Container());
-
-T     bool      empty() const             { return c.empty(); }
-T     size_type size()  const             { return c.size(); }
-T     value_type&amp;       front()           { return c.front(); }
-T     const value_type&amp; front() const     { return c.front(); }
-T     value_type&amp;       back()            { return c.back(); }
-T     const value_type&amp; back() const      { return c.back(); }
-T     void push(const value_type&amp; x)      { c.push_back(x); }
-T     void pop()                          { c.pop_front(); }
-    };
-
-T   template &lt;class T, class Container&gt;
-      bool operator==(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt; (const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator!=(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt; (const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x,
-                      const queue&lt;T, Container&gt;&amp; y);
-
-   23.2.3.2  Template class priority_queue           [lib.priority.queue]
-
-T   template &lt;class T, class Container = vector&lt;T&gt;,
-              class Compare = less&lt;typename Container::value_type&gt; &gt;
-    class priority_queue {
-    public:
-T     typedef typename Container::value_type            value_type;
-T     typedef typename Container::size_type             size_type;
-T     typedef          Container                        container_type;
-    protected:
-T     Container c;
-T     Compare comp;
-    public:
-T     explicit priority_queue(const Compare&amp; x = Compare(),
-                              const Container&amp; = Container());
-T     template &lt;class InputIterator&gt;
-        priority_queue(InputIterator first, InputIterator last,
-                       const Compare&amp; x = Compare(),
-                       const Container&amp; = Container());
-
-T     bool      empty() const       { return c.empty(); }
-T     size_type size()  const       { return c.size(); }
-T     const value_type&amp; top() const { return c.front(); }
-T     void push(const value_type&amp; x);
-T     void pop();
-    };
-
-   23.2.3.3  Template class stack                             [lib.stack]
-
-T   template &lt;class T, class Container = deque&lt;T&gt; &gt;
-    class stack {
-    public:
-T     typedef typename Container::value_type            value_type;
-T     typedef typename Container::size_type             size_type;
-T     typedef          Container                        container_type;
-    protected:
-T     Container c;
-    public:
-T     explicit stack(const Container&amp; = Container());
-
-T     bool      empty() const             { return c.empty(); }
-T     size_type size()  const             { return c.size(); }
-T     value_type&amp;       top()             { return c.back(); }
-T     const value_type&amp; top() const       { return c.back(); }
-T     void push(const value_type&amp; x)      { c.push_back(x); }
-T     void pop()                          { c.pop_back(); }
-    };
-T   template &lt;class T, class Container&gt;
-      bool operator==(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt; (const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator!=(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt; (const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-T   template &lt;class T, class Container&gt;
-      bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x,
-                      const stack&lt;T, Container&gt;&amp; y);
-
-   23.2.4  Template class vector                             [lib.vector]
-
-    template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
-T   class vector {
-    public:
-      // types:
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef T                                     value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-      // _lib.vector.cons_ construct/copy/destroy:
-T     explicit vector(const Allocator&amp; = Allocator());
-T     explicit vector(size_type n, const T&amp; value = T(),
-          const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        vector(InputIterator first, InputIterator last,
-          const Allocator&amp; = Allocator());
-T     vector(const vector&lt;T,Allocator&gt;&amp; x);
-T    ~vector();
-T     vector&lt;T,Allocator&gt;&amp; operator=(const vector&lt;T,Allocator&gt;&amp; x);
-T     template &lt;class InputIterator&gt;
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T&amp; u);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // _lib.vector.capacity_ capacity:
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, T c = T());
-T     size_type capacity() const;
-T     bool      empty() const;
-T     void      reserve(size_type n);
-
-      // element access:
-T     reference       operator[](size_type n);
-T     const_reference operator[](size_type n) const;
-T     const_reference at(size_type n) const;
-T     reference       at(size_type n);
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // _lib.vector.modifiers_ modifiers:
-T     void push_back(const T&amp; x);
-T     void pop_back();
-T     iterator insert(iterator position, const T&amp; x);
-T     void     insert(iterator position, size_type n, const T&amp; x);
-T     template &lt;class InputIterator&gt;
-          void insert(iterator position,
-                      InputIterator first, InputIterator last);
-T     iterator erase(iterator position);
-T     iterator erase(iterator first, iterator last);
-T     void     swap(vector&lt;T,Allocator&gt;&amp;);
-T     void     clear();
-    };
-
-T   template &lt;class T, class Allocator&gt;
-      bool operator==(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt; (const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator!=(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt; (const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&gt;=(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-T   template &lt;class T, class Allocator&gt;
-      bool operator&lt;=(const vector&lt;T,Allocator&gt;&amp; x,
-                      const vector&lt;T,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class T, class Allocator&gt;
-      void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
-
-
-   23.2.5  Class vector&lt;bool&gt;                           [lib.vector.bool]
-
-T   template &lt;class Allocator&gt; class vector&lt;bool, Allocator&gt; {
-    public:
-      // types:
-T     typedef bool                                  const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef bool                                  value_type;
-T     typedef Allocator                             allocator_type;
-T     typedef implementation defined                pointer;
-T     typedef implementation defined                const_pointer
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-      // bit reference:
-T     class reference {
-       friend class vector;
-T      reference();
-      public:
-T      ~reference();
-T       operator bool() const;
-T       reference&amp; operator=(const bool x);
-T       reference&amp; operator=(const reference&amp; x);
-T       void flip();              // flips the bit
-      };
-
-      // construct/copy/destroy:
-T     explicit vector(const Allocator&amp; = Allocator());
-T     explicit vector(size_type n, const bool&amp; value = bool(),
-                      const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        vector(InputIterator first, InputIterator last,
-          const Allocator&amp; = Allocator());
-T     vector(const vector&lt;bool,Allocator&gt;&amp; x);
-T    ~vector();
-T     vector&lt;bool,Allocator&gt;&amp; operator=(const vector&lt;bool,Allocator&gt;&amp; x);
-T     template &lt;class InputIterator&gt;
-        void assign(InputIterator first, InputIterator last);
-T     void assign(size_type n, const T&amp; t);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     size_type size() const;
-T     size_type max_size() const;
-T     void      resize(size_type sz, bool c = false);
-T     size_type capacity() const;
-T     bool      empty() const;
-T     void      reserve(size_type n);
-      // element access:
-T     reference       operator[](size_type n);
-T     const_reference operator[](size_type n) const;
-T     const_reference at(size_type n) const;
-T     reference       at(size_type n);
-T     reference       front();
-T     const_reference front() const;
-T     reference       back();
-T     const_reference back() const;
-      // modifiers:
-T     void push_back(const bool&amp; x);
-T     void pop_back();
-T     iterator insert(iterator position, const bool&amp; x);
-T     void     insert (iterator position, size_type n, const bool&amp; x);
-T     template &lt;class InputIterator&gt;
-          void insert(iterator position,
-                      InputIterator first, InputIterator last);
-T     iterator erase(iterator position);
-T     iterator erase(iterator first, iterator last);
-T     void swap(vector&lt;bool,Allocator&gt;&amp;);
-T     static void swap(reference x, reference y);
-T     void flip();                // flips all bits
-T     void clear();
-    };
-
-T   template &lt;class Allocator&gt;
-      bool operator==(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&lt; (const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator!=(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&gt; (const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&gt;=(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-T   template &lt;class Allocator&gt;
-      bool operator&lt;=(const vector&lt;bool,Allocator&gt;&amp; x,
-                      const vector&lt;bool,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class Allocator&gt;
-      void swap(vector&lt;bool,Allocator&gt;&amp; x, vector&lt;bool,Allocator&gt;&amp; y);
-
-   23.3  Associative containers                         [lib.associative]
-
- &lt;map&gt; and &lt;set&gt;:
-
-   Header &lt;map&gt; synopsis
-
-    template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
-T     class map;
-
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator==(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator!=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
-      class multimap;
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator==(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator!=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-   }
-
-   Header &lt;set&gt; synopsis
-
-    template &lt;class Key, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;Key&gt; &gt;
-T     class set;
-
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator==(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator!=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      void swap(set&lt;Key,Compare,Allocator&gt;&amp; x,
-                set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;Key&gt; &gt;
-      class multiset;
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator==(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator!=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-   }
-
-   23.3.1  Template class map                                   [lib.map]
-
-    template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
-T     class map {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef T                                     mapped_type;
-T     typedef pair&lt;const Key, T&gt;                    value_type;
-T     typedef Compare                               key_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-T     class value_compare
-        : public binary_function&lt;value_type,value_type,bool&gt; {
-      friend class map;
-      protected:
-T       Compare comp;
-T       value_compare(Compare c) : comp(c) {}
-      public:
-T       bool operator()(const value_type&amp; x, const value_type&amp; y) const {
-          return comp(x.first, y.first);
-        }
-      };
-
-      // _lib.map.cons_ construct/copy/destroy:
-T     explicit map(const Compare&amp; comp = Compare(),
-                   const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        map(InputIterator first, InputIterator last,
-            const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
-T     map(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);
-T    ~map();
-T     map&lt;Key,T,Compare,Allocator&gt;&amp;
-        operator=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool      empty() const;
-T     size_type size() const;
-T     size_type max_size() const;
-      // _lib.map.access_ element access:
-T     T&amp; operator[](const key_type&amp; x);
-      // modifiers:
-T     pair&lt;iterator, bool&gt; insert(const value_type&amp; x);
-T     iterator             insert(iterator position, const value_type&amp; x);
-T     template &lt;class InputIterator&gt;
-        void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type&amp; x);
-T     void      erase(iterator first, iterator last);
-T     void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;);
-T     void clear();
-      // observers:
-T     key_compare   key_comp() const;
-T     value_compare value_comp() const;
-      // _lib.map.ops_ map operations:
-T     iterator       find(const key_type&amp; x);
-T     const_iterator find(const key_type&amp; x) const;
-T     size_type      count(const key_type&amp; x) const;
-T     iterator       lower_bound(const key_type&amp; x);
-T     const_iterator lower_bound(const key_type&amp; x) const;
-T     iterator       upper_bound(const key_type&amp; x);
-T     const_iterator upper_bound(const key_type&amp; x) const;
-T     pair&lt;iterator,iterator&gt;
-          equal_range(const key_type&amp; x);
-T     pair&lt;const_iterator,const_iterator&gt;
-          equal_range(const key_type&amp; x) const;
-    };
-
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator==(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator!=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                map&lt;Key,T,Compare,Allocator&gt;&amp; y);
-
-   23.3.2  Template class multimap                         [lib.multimap]
-
-    template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
-T   class multimap {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef T                                     mapped_type;
-T     typedef pair&lt;const Key,T&gt;                     value_type;
-T     typedef Compare                               key_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-T     class value_compare
-        : public binary_function&lt;value_type,value_type,bool&gt; {
-      friend class multimap;
-      protected:
-T       Compare comp;
-T       value_compare(Compare c) : comp(c) {}
-      public:
-T       bool operator()(const value_type&amp; x, const value_type&amp; y) const {
-          return comp(x.first, y.first);
-        }
-      };
-      // construct/copy/destroy:
-T     explicit multimap(const Compare&amp; comp = Compare(),
-                        const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        multimap(InputIterator first, InputIterator last,
-                 const Compare&amp; comp = Compare(),
-                 const Allocator&amp; = Allocator());
-T     multimap(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);
-T    ~multimap();
-T     multimap&lt;Key,T,Compare,Allocator&gt;&amp;
-        operator=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);
-T     allocator_type get_allocator() const;
-
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool           empty() const;
-T     size_type      size() const;
-T     size_type      max_size() const;
-      // modifiers:
-T     iterator insert(const value_type&amp; x);
-T     iterator insert(iterator position, const value_type&amp; x);
-T     template &lt;class InputIterator&gt;
-        void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type&amp; x);
-T     void      erase(iterator first, iterator last);
-T     void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;);
-T     void clear();
-      // observers:
-T     key_compare    key_comp() const;
-T     value_compare  value_comp() const;
-      // map operations:
-T     iterator       find(const key_type&amp; x);
-T     const_iterator find(const key_type&amp; x) const;
-T     size_type      count(const key_type&amp; x) const;
-T     iterator       lower_bound(const key_type&amp; x);
-T     const_iterator lower_bound(const key_type&amp; x) const;
-T     iterator       upper_bound(const key_type&amp; x);
-T     const_iterator upper_bound(const key_type&amp; x) const;
-T     pair&lt;iterator,iterator&gt;             equal_range(const key_type&amp; x);
-T     pair&lt;const_iterator,const_iterator&gt; equal_range(const key_type&amp; x) const;
-    };
-
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator==(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator!=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&gt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      bool operator&lt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                      const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class Key, class T, class Compare, class Allocator&gt;
-      void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
-                multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
-
-
-   23.3.3  Template class set                                   [lib.set]
-
-    template &lt;class Key, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;Key&gt; &gt;
-T   class set {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef Key                                   value_type;
-T     typedef Compare                               key_compare;
-T     typedef Compare                               value_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type;
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-      // _lib.set.cons_ construct/copy/destroy:
-T     explicit set(const Compare&amp; comp = Compare(),
-                   const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        set(InputIterator first, InputIterator last,
-            const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
-T     set(const set&lt;Key,Compare,Allocator&gt;&amp; x);
-T    ~set();
-T     set&lt;Key,Compare,Allocator&gt;&amp;
-        operator=(const set&lt;Key,Compare,Allocator&gt;&amp; x);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool          empty() const;
-T     size_type     size() const;
-T     size_type     max_size() const;
-      // modifiers:
-T     pair&lt;iterator,bool&gt; insert(const value_type&amp; x);
-T     iterator            insert(iterator position, const value_type&amp; x);
-T     template &lt;class InputIterator&gt;
-T         void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type&amp; x);
-T     void      erase(iterator first, iterator last);
-T     void swap(set&lt;Key,Compare,Allocator&gt;&amp;);
-T     void clear();
-
-      // observers:
-T     key_compare   key_comp() const;
-T     value_compare value_comp() const;
-      // set operations:
-T     iterator  find(const key_type&amp; x) const;
-T     size_type count(const key_type&amp; x) const;
-T     iterator  lower_bound(const key_type&amp; x) const;
-T     iterator  upper_bound(const key_type&amp; x) const;
-T     pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x) const;
-    };
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator==(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator!=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const set&lt;Key,Compare,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      void swap(set&lt;Key,Compare,Allocator&gt;&amp; x,
-                set&lt;Key,Compare,Allocator&gt;&amp; y);
-
-   23.3.4  Template class multiset                         [lib.multiset]
-
-    template &lt;class Key, class Compare = less&lt;Key&gt;,
-              class Allocator = allocator&lt;Key&gt; &gt;
-T   class multiset {
-    public:
-      // types:
-T     typedef Key                                   key_type;
-T     typedef Key                                   value_type;
-T     typedef Compare                               key_compare;
-T     typedef Compare                               value_compare;
-T     typedef Allocator                             allocator_type;
-T     typedef typename Allocator::reference         reference;
-T     typedef typename Allocator::const_reference   const_reference;
-T     typedef implementation defined                iterator;
-T     typedef implementation defined                const_iterator;
-T     typedef implementation defined                size_type;
-T     typedef implementation defined                difference_type
-T     typedef typename Allocator::pointer           pointer;
-T     typedef typename Allocator::const_pointer     const_pointer;
-T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
-T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
-
-      // construct/copy/destroy:
-T     explicit multiset(const Compare&amp; comp = Compare(),
-                        const Allocator&amp; = Allocator());
-T     template &lt;class InputIterator&gt;
-        multiset(InputIterator first, InputIterator last,
-                 const Compare&amp; comp = Compare(),
-                 const Allocator&amp; = Allocator());
-T     multiset(const multiset&lt;Key,Compare,Allocator&gt;&amp; x);
-T    ~multiset();
-T     multiset&lt;Key,Compare,Allocator&gt;&amp;
-          operator=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x);
-T     allocator_type get_allocator() const;
-      // iterators:
-T     iterator               begin();
-T     const_iterator         begin() const;
-T     iterator               end();
-T     const_iterator         end() const;
-T     reverse_iterator       rbegin();
-T     const_reverse_iterator rbegin() const;
-T     reverse_iterator       rend();
-T     const_reverse_iterator rend() const;
-      // capacity:
-T     bool          empty() const;
-T     size_type     size() const;
-T     size_type     max_size() const;
-      // modifiers:
-T     iterator insert(const value_type&amp; x);
-T     iterator insert(iterator position, const value_type&amp; x);
-T     template &lt;class InputIterator&gt;
-        void insert(InputIterator first, InputIterator last);
-T     void      erase(iterator position);
-T     size_type erase(const key_type&amp; x);
-T     void      erase(iterator first, iterator last);
-T     void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;);
-T     void clear();
-      // observers:
-T     key_compare   key_comp() const;
-T     value_compare value_comp() const;
-      // set operations:
-T     iterator  find(const key_type&amp; x) const;
-T     size_type count(const key_type&amp; x) const;
-T     iterator  lower_bound(const key_type&amp; x) const;
-T     iterator  upper_bound(const key_type&amp; x) const;
-T     pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x) const;
-    };
-
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator==(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator!=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&gt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      bool operator&lt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                      const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-    // specialized algorithms:
-T   template &lt;class Key, class Compare, class Allocator&gt;
-      void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x,
-                multiset&lt;Key,Compare,Allocator&gt;&amp; y);
-
-   23.3.5  Template class bitset                    [lib.template.bitset]
-
-   Header &lt;bitset&gt; synopsis
-
-T   template &lt;size_t N&gt; class bitset;
-    // _lib.bitset.operators_ bitset operations:
-T   template &lt;size_t N&gt;
-      bitset&lt;N&gt; operator&amp;(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);
-T   template &lt;size_t N&gt;
-      bitset&lt;N&gt; operator|(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);
-T   template &lt;size_t N&gt;
-      bitset&lt;N&gt; operator^(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);
-T   template &lt;class charT, class traits, size_t N&gt;
-      basic_istream&lt;charT, traits&gt;&amp;
-      operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, bitset&lt;N&gt;&amp; x);
-T   template &lt;class charT, class traits, size_t N&gt;
-      basic_ostream&lt;charT, traits&gt;&amp;
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const bitset&lt;N&gt;&amp; x);
-
-T   template&lt;size_t N&gt; class bitset {
-    public:
-      // bit reference:
-T     class reference {
-        friend class bitset;
-T       reference();
-      public:
-T      ~reference();
-T       reference&amp; operator=(bool x);             // for b[i] = x;
-T       reference&amp; operator=(const reference&amp;);   // for b[i] = b[j];
-T       bool operator~() const;                   // flips the bit
-T       operator bool() const;                    // for x = b[i];
-T       reference&amp; flip();                        // for b[i].flip();
-      };
-
-      // _lib.bitset.cons_ constructors:
-T     bitset();
-T     bitset(unsigned long val);
-T     template&lt;class charT, class traits, class Allocator&gt;
-        explicit bitset(
-          const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
-          typename basic_string&lt;charT,traits,Allocator&gt;::size_type pos = 0,
-          typename basic_string&lt;charT,traits,Allocator&gt;::size_type n =
-            basic_string&lt;charT,traits,Allocator&gt;::npos);
-      // _lib.bitset.members_ bitset operations:
-T     bitset&lt;N&gt;&amp; operator&amp;=(const bitset&lt;N&gt;&amp; rhs);
-T     bitset&lt;N&gt;&amp; operator|=(const bitset&lt;N&gt;&amp; rhs);
-T     bitset&lt;N&gt;&amp; operator^=(const bitset&lt;N&gt;&amp; rhs);
-T     bitset&lt;N&gt;&amp; operator&lt;&lt;=(size_t pos);
-T     bitset&lt;N&gt;&amp; operator&gt;&gt;=(size_t pos);
-T     bitset&lt;N&gt;&amp; set();
-T     bitset&lt;N&gt;&amp; set(size_t pos, int val = true);
-T     bitset&lt;N&gt;&amp; reset();
-T     bitset&lt;N&gt;&amp; reset(size_t pos);
-T     bitset&lt;N&gt;  operator~() const;
-T     bitset&lt;N&gt;&amp; flip();
-T     bitset&lt;N&gt;&amp; flip(size_t pos);
-      // element access:
-T     reference operator[](size_t pos);         // for b[i];
-T     unsigned long  to_ulong() const;
-T     template &lt;class charT, class traits, class Allocator&gt;
-        basic_string&lt;charT, traits, Allocator&gt; to_string() const;
-T     size_t count() const;
-T     size_t size()  const;
-T     bool operator==(const bitset&lt;N&gt;&amp; rhs) const;
-T     bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
-T     bool test(size_t pos) const;
-T     bool any() const;
-T     bool none() const;
-T     bitset&lt;N&gt; operator&lt;&lt;(size_t pos) const;
-T     bitset&lt;N&gt; operator&gt;&gt;(size_t pos) const;
-    };
-
-
-
-
-   24.2  Header &lt;iterator&gt; synopsis               [lib.iterator.synopsis]
-
-    // _lib.iterator.primitives_, primitives:
-T   template&lt;class Iterator&gt; struct iterator_traits;
-T   template&lt;class T&gt; struct iterator_traits&lt;T*&gt;;
-
-X   template&lt;class Category, class T, class Distance = ptrdiff_t,
-             class Pointer = T*, class Reference = T&amp;&gt; struct iterator;
-T   struct input_iterator_tag {};
-T   struct output_iterator_tag {};
-T   struct forward_iterator_tag: public input_iterator_tag {};
-T   struct bidirectional_iterator_tag: public forward_iterator_tag {};
-T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};
-    // _lib.iterator.operations_, iterator operations:
-T   template &lt;class InputIterator, class Distance&gt;
-      void advance(InputIterator&amp; i, Distance n);
-T   template &lt;class InputIterator&gt;
-      typename iterator_traits&lt;InputIterator&gt;::difference_type
-      distance(InputIterator first, InputIterator last);
-    // _lib.predef.iterators_, predefined iterators:
-X   template &lt;class Iterator&gt; class reverse_iterator;
-T   template &lt;class Iterator&gt;
-      bool operator==(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&lt;(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator!=(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&gt;(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&gt;=(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&lt;=(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      typename reverse_iterator&lt;Iterator&gt;::difference_type operator-(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      reverse_iterator&lt;Iterator&gt;
-        operator+(
-          typename reverse_iterator&lt;Iterator&gt;::difference_type n,
-          const reverse_iterator&lt;Iterator&gt;&amp; x);
-
-X   template &lt;class Container&gt; class back_insert_iterator;
-T   template &lt;class Container&gt;
-      back_insert_iterator&lt;Container&gt; back_inserter(Container&amp; x);
-X   template &lt;class Container&gt; class front_insert_iterator;
-T   template &lt;class Container&gt;
-      front_insert_iterator&lt;Container&gt; front_inserter(Container&amp; x);
-X   template &lt;class Container&gt; class insert_iterator;
-T   template &lt;class Container, class Iterator&gt;
-      insert_iterator&lt;Container&gt; inserter(Container&amp; x, Iterator i);
-    // _lib.stream.iterators_, stream iterators:
-X   template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,
-              class Distance = ptrdiff_t&gt;
-      class istream_iterator;
-    template &lt;class T, class charT, class traits, class Distance&gt;
-X     bool operator==(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
-    template &lt;class T, class charT, class traits, class Distance&gt;
-X     bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
-X   template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt; &gt;
-        class ostream_iterator;
-X   template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class istreambuf_iterator;
-X   template &lt;class charT, class traits&gt;
-      bool operator==(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
-X   template &lt;class charT, class traits&gt;
-      bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
-T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class ostreambuf_iterator;
-
-   24.3  Iterator primitives                    [lib.iterator.primitives]
-
-T   template&lt;class Iterator&gt; struct iterator_traits {
-T     typedef typename Iterator::difference_type difference_type;
-T     typedef typename Iterator::value_type value_type;
-T     typedef typename Iterator::pointer pointer;
-T     typedef typename Iterator::reference reference;
-T     typedef typename Iterator::iterator_category iterator_category;
-    };
-
-T   template&lt;class T&gt; struct iterator_traits&lt;T*&gt; {
-T     typedef ptrdiff_t difference_type;
-T     typedef T value_type;
-T     typedef T* pointer;
-T     typedef T&amp; reference;
-T     typedef random_access_iterator_tag iterator_category;
-    };
-
-T   template&lt;class T&gt; struct iterator_traits&lt;const T*&gt; {
-T     typedef ptrdiff_t difference_type;
-T     typedef T value_type;
-T     typedef const T* pointer;
-T     typedef const T&amp; reference;
-T     typedef random_access_iterator_tag iterator_category;
-    };
-
-   24.3.2  Basic iterator                            [lib.iterator.basic]
-
-    template&lt;class Category, class T, class Distance = ptrdiff_t,
-             class Pointer = T*, class Reference = T&amp;&gt;
-X     struct iterator {
-T         typedef T         value_type;
-T         typedef Distance  difference_type;
-T         typedef Pointer   pointer;
-T         typedef Reference reference;
-T         typedef Category  iterator_category;
-    };
-
-   24.3.3  Standard iterator tags                 [lib.std.iterator.tags]
-
-T   struct input_iterator_tag {};
-T   struct output_iterator_tag {};
-T   struct forward_iterator_tag: public input_iterator_tag {};
-T   struct bidirectional_iterator_tag: public forward_iterator_tag {};
-T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};
-
-
-   24.4.1  Reverse iterators                      [lib.reverse.iterators]
-
-    template &lt;class Iterator&gt;
-X   class reverse_iterator : public
-          iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
-                   typename iterator_traits&lt;Iterator&gt;::value_type,
-                   typename iterator_traits&lt;Iterator&gt;::difference_type,
-                   typename iterator_traits&lt;Iterator&gt;::pointer,
-                   typename iterator_traits&lt;Iterator&gt;::reference&gt; {
-    protected:
-T     Iterator current;
-    public:
-T     typedef Iterator
-          iterator_type;
-T     typedef typename iterator_traits&lt;Iterator&gt;::difference_type
-          difference_type;
-T     typedef typename iterator_traits&lt;Iterator&gt;::reference
-          reference;
-T     typedef typename iterator_traits&lt;Iterator&gt;::pointer
-          pointer;
-
-T     reverse_iterator();
-T     explicit reverse_iterator(Iterator x);
-T     template &lt;class U&gt; reverse_iterator(const reverse_iterator&lt;U&gt;&amp; u);
-T     Iterator base() const;      // explicit
-T     reference operator*() const;
-T     pointer   operator-&gt;() const;
-T     reverse_iterator&amp; operator++();
-T     reverse_iterator  operator++(int);
-T     reverse_iterator&amp; operator--();
-T     reverse_iterator  operator--(int);
-
-T     reverse_iterator  operator+ (difference_type n) const;
-T     reverse_iterator&amp; operator+=(difference_type n);
-T     reverse_iterator  operator- (difference_type n) const;
-T     reverse_iterator&amp; operator-=(difference_type n);
-T     reference operator[](difference_type n) const;
-    };
-T   template &lt;class Iterator&gt;
-      bool operator==(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&lt;(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator!=(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&gt;(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&gt;=(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      bool operator&lt;=(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      typename reverse_iterator&lt;Iterator&gt;::difference_type operator-(
-        const reverse_iterator&lt;Iterator&gt;&amp; x,
-        const reverse_iterator&lt;Iterator&gt;&amp; y);
-T   template &lt;class Iterator&gt;
-      reverse_iterator&lt;Iterator&gt; operator+(
-        typename reverse_iterator&lt;Iterator&gt;::difference_type n,
-        const reverse_iterator&lt;Iterator&gt;&amp; x);
-
-
-   24.4.2.1  Template class                    [lib.back.insert.iterator]
-       back_insert_iterator
-
-    template &lt;class Container&gt;
-X   class back_insert_iterator :
-          public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
-    protected:
-T     Container* container;
-    public:
-T     typedef Container container_type;
-T     explicit back_insert_iterator(Container&amp; x);
-T     back_insert_iterator&lt;Container&gt;&amp;
-        operator=(typename Container::const_reference value);
-
-T     back_insert_iterator&lt;Container&gt;&amp; operator*();
-T     back_insert_iterator&lt;Container&gt;&amp; operator++();
-T     back_insert_iterator&lt;Container&gt;  operator++(int);
-    };
-T   template &lt;class Container&gt;
-      back_insert_iterator&lt;Container&gt; back_inserter(Container&amp; x);
-
-
-
-   24.4.2.3  Template class                   [lib.front.insert.iterator]
-       front_insert_iterator
-
-    template &lt;class Container&gt;
-X   class front_insert_iterator :
-          public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
-    protected:
-T     Container* container;
-    public:
-T     typedef Container container_type;
-T     explicit front_insert_iterator(Container&amp; x);
-T     front_insert_iterator&lt;Container&gt;&amp;
-        operator=(typename Container::const_reference value);
-T     front_insert_iterator&lt;Container&gt;&amp; operator*();
-T     front_insert_iterator&lt;Container&gt;&amp; operator++();
-T     front_insert_iterator&lt;Container&gt;  operator++(int);
-    };
-T   template &lt;class Container&gt;
-      front_insert_iterator&lt;Container&gt; front_inserter(Container&amp; x);
-
-
-   24.4.2.5  Template class insert_iterator         [lib.insert.iterator]
-
-    template &lt;class Container&gt;
-X   class insert_iterator :
-          public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
-    protected:
-T     Container* container;
-T     typename Container::iterator iter;
-    public:
-T     typedef Container container_type;
-T     insert_iterator(Container&amp; x, typename Container::iterator i);
-T     insert_iterator&lt;Container&gt;&amp;
-        operator=(typename Container::const_reference value);
-T     insert_iterator&lt;Container&gt;&amp; operator*();
-T     insert_iterator&lt;Container&gt;&amp; operator++();
-T     insert_iterator&lt;Container&gt;&amp; operator++(int);
-    };
-T   template &lt;class Container, class Iterator&gt;
-      insert_iterator&lt;Container&gt; inserter(Container&amp; x, Iterator i);
-
-   24.5.1  Template class istream_iterator         [lib.istream.iterator]
-
-    template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,
-        class Distance = ptrdiff_t&gt;
-X   class istream_iterator:
-      public iterator&lt;input_iterator_tag, T, Distance, const T*, const T&amp;&gt; {
-    public:
-T     typedef charT char_type
-T     typedef traits traits_type;
-T     typedef basic_istream&lt;charT,traits&gt; istream_type;
-T     istream_iterator();
-T     istream_iterator(istream_type&amp; s);
-T     istream_iterator(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x);
-T    ~istream_iterator();
-
-T     const T&amp; operator*() const;
-T     const T* operator-&gt;() const;
-T     istream_iterator&lt;T,charT,traits,Distance&gt;&amp; operator++();
-T     istream_iterator&lt;T,charT,traits,Distance&gt;  operator++(int);
-    };
-
-T   template &lt;class T, class charT, class traits, class Distance&gt;
-      bool operator==(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
-T   template &lt;class T, class charT, class traits, class Distance&gt;
-      bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
-                      const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
-
-
-   24.5.2  Template class ostream_iterator         [lib.ostream.iterator]
-
-    template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt; &gt;
-X   class ostream_iterator:
-      public iterator&lt;output_iterator_tag, void, void, void, void&gt; {
-    public:
-T     typedef charT char_type;
-T     typedef traits traits_type;
-T     typedef basic_ostream&lt;charT,traits&gt; ostream_type;
-T     ostream_iterator(ostream_type&amp; s);
-T     ostream_iterator(ostream_type&amp; s, const charT* delimiter);
-T     ostream_iterator(const ostream_iterator&lt;T,charT,traits&gt;&amp; x);
-T    ~ostream_iterator();
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator=(const T&amp; value);
-
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator*();
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator++();
-T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator++(int);
-    };
-
-
-   24.5.3  Template class                       [lib.istreambuf.iterator]
-       istreambuf_iterator
-
-    template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-X   class istreambuf_iterator
-       : public iterator&lt;input_iterator_tag, charT,
-                         typename traits::off_type, charT*, charT&amp;&gt; {
-    public:
-T     typedef charT                         char_type;
-T     typedef traits                        traits_type;
-T     typedef typename traits::int_type     int_type;
-T     typedef basic_streambuf&lt;charT,traits&gt; streambuf_type;
-T     typedef basic_istream&lt;charT,traits&gt;   istream_type;
-T     class proxy;                        // exposition only
-T     istreambuf_iterator() throw();
-T     istreambuf_iterator(istream_type&amp; s) throw();
-T     istreambuf_iterator(streambuf_type* s) throw();
-T     istreambuf_iterator(const proxy&amp; p) throw();
-T     charT operator*() const;
-T     istreambuf_iterator&lt;charT,traits&gt;&amp; operator++();
-T     proxy operator++(int);
-X     bool equal(istreambuf_iterator&amp; b);
-    };
-
-T   template &lt;class charT, class traits&gt;
-      bool operator==(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
-
-T   template &lt;class charT, class traits&gt;
-      bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
-                      const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
-
-   24.5.3.1  Template class              [lib.istreambuf.iterator::proxy]
-       istreambuf_iterator::proxy
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-T     class istreambuf_iterator&lt;charT, traits&gt;::proxy
-    {
-T     charT keep_;
-T     basic_streambuf&lt;charT,traits&gt;* sbuf_;
-T     proxy(charT c,
-            basic_streambuf&lt;charT,traits&gt;* sbuf);
-        : keep_(c), sbuf_(sbuf) {}
-    public:
-T     charT operator*() { return keep_; }
-    };
-
-
-
-   24.5.4  Template class                       [lib.ostreambuf.iterator]
-       ostreambuf_iterator
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-T   class ostreambuf_iterator:
-      public iterator&lt;output_iterator_tag, void, void, void, void&gt; {
-    public:
-T     typedef charT                         char_type;
-T     typedef traits                        traits_type;
-T     typedef basic_streambuf&lt;charT,traits&gt; streambuf_type;
-T     typedef basic_ostream&lt;charT,traits&gt;   ostream_type;
-    public:
-T     ostreambuf_iterator(ostream_type&amp; s) throw();
-T     ostreambuf_iterator(streambuf_type* s) throw();
-T     ostreambuf_iterator&amp; operator=(charT c);
-T     ostreambuf_iterator&amp; operator*();
-T     ostreambuf_iterator&amp; operator++();
-T     ostreambuf_iterator&amp; operator++(int);
-T     bool failed() const throw();
-    };
-
-
-   Header &lt;algorithm&gt; synopsis
-
-
-    // _lib.alg.nonmodifying_, non-modifying sequence operations:
-T   template&lt;class InputIterator, class Function&gt;
-      Function for_each(InputIterator first, InputIterator last, Function f);
-T   template&lt;class InputIterator, class T&gt;
-      InputIterator find(InputIterator first, InputIterator last,
-                         const T&amp; value);
-T   template&lt;class InputIterator, class Predicate&gt;
-      InputIterator find_if(InputIterator first, InputIterator last,
-                            Predicate pred);
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
-      ForwardIterator1
-        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                 ForwardIterator2 first2, ForwardIterator2 last2);
-T   template&lt;class ForwardIterator1, class ForwardIterator2,
-             class BinaryPredicate&gt;
-      ForwardIterator1
-        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
-                 ForwardIterator2 first2, ForwardIterator2 last2,
-                 BinaryPredicate pred);
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
-      ForwardIterator1
-        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                      ForwardIterator2 first2, ForwardIterator2 last2);
-T   template&lt;class ForwardIterator1, class ForwardIterator2,
-             class BinaryPredicate&gt;
-      ForwardIterator1
-        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
-                 ForwardIterator2 first2, ForwardIterator2 last2,
-                 BinaryPredicate pred);
-T   template&lt;class ForwardIterator&gt;
-      ForwardIterator adjacent_find(ForwardIterator first,
-                                    ForwardIterator last);
-T   template&lt;class ForwardIterator, class BinaryPredicate&gt;
-      ForwardIterator adjacent_find(ForwardIterator first,
-          ForwardIterator last, BinaryPredicate pred);
-T   template&lt;class InputIterator, class T&gt;
-      typename iterator_traits&lt;InputIterator&gt;::difference_type
-        count(InputIterator first, InputIterator last, const T&amp; value);
-T   template&lt;class InputIterator, class Predicate&gt;
-      typename iterator_traits&lt;InputIterator&gt;::difference_type
-        count_if(InputIterator first, InputIterator last, Predicate pred);
-T   template&lt;class InputIterator1, class InputIterator2&gt;
-      pair&lt;InputIterator1, InputIterator2&gt;
-        mismatch(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2);
-T   template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;
-      pair&lt;InputIterator1, InputIterator2&gt;
-        mismatch(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2, BinaryPredicate pred);
-
-T   template&lt;class InputIterator1, class InputIterator2&gt;
-      bool equal(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2);
-T   template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;
-      bool equal(InputIterator1 first1, InputIterator1 last1,
-                 InputIterator2 first2, BinaryPredicate pred);
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
-      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
-                              ForwardIterator2 first2, ForwardIterator2 last2);
-T   template&lt;class ForwardIterator1, class ForwardIterator2,
-             class BinaryPredicate&gt;
-      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
-                              ForwardIterator2 first2, ForwardIterator2 last2,
-                              BinaryPredicate pred);
-T   template&lt;class ForwardIterator, class Size, class T&gt;
-      ForwardIterator  search_n(ForwardIterator first, ForwardIterator last,
-                              Size count, const T&amp; value);
-T   template&lt;class ForwardIterator, class Size, class T, class BinaryPredicate&gt;
-      ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
-                              Size count, const T&amp; value,
-                              BinaryPredicate pred);
-    // _lib.alg.modifying.operations_, modifying sequence operations:
-    // _lib.alg.copy_, copy:
-T   template&lt;class InputIterator, class OutputIterator&gt;
-      OutputIterator copy(InputIterator first, InputIterator last,
-                          OutputIterator result);
-T   template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
-      BidirectionalIterator2
-        copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
-                      BidirectionalIterator2 result);
-    // _lib.alg.swap_, swap:
-T   template&lt;class T&gt; void swap(T&amp; a, T&amp; b);
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
-      ForwardIterator2 swap_ranges(ForwardIterator1 first1,
-          ForwardIterator1 last1, ForwardIterator2 first2);
-T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
-      void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
-T   template&lt;class InputIterator, class OutputIterator, class UnaryOperation&gt;
-      OutputIterator transform(InputIterator first, InputIterator last,
-                               OutputIterator result, UnaryOperation op);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
-             class BinaryOperation&gt;
-      OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, OutputIterator result,
-                               BinaryOperation binary_op);
-
-T   template&lt;class ForwardIterator, class T&gt;
-      void replace(ForwardIterator first, ForwardIterator last,
-                   const T&amp; old_value, const T&amp; new_value);
-T   template&lt;class ForwardIterator, class Predicate, class T&gt;
-      void replace_if(ForwardIterator first, ForwardIterator last,
-                      Predicate pred, const T&amp; new_value);
-T   template&lt;class InputIterator, class OutputIterator, class T&gt;
-      OutputIterator replace_copy(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  const T&amp; old_value, const T&amp; new_value);
-T   template&lt;class Iterator, class OutputIterator, class Predicate, class T&gt;
-      OutputIterator replace_copy_if(Iterator first, Iterator last,
-                                     OutputIterator result,
-                                     Predicate pred, const T&amp; new_value);
-T   template&lt;class ForwardIterator, class T&gt;
-      void fill(ForwardIterator first, ForwardIterator last, const T&amp; value);
-T   template&lt;class OutputIterator, class Size, class T&gt;
-      void fill_n(OutputIterator first, Size n, const T&amp; value);
-T   template&lt;class ForwardIterator, class Generator&gt;
-      void generate(ForwardIterator first, ForwardIterator last, Generator gen);
-T   template&lt;class OutputIterator, class Size, class Generator&gt;
-      void generate_n(OutputIterator first, Size n, Generator gen);
-T   template&lt;class ForwardIterator, class T&gt;
-      ForwardIterator remove(ForwardIterator first, ForwardIterator last,
-                             const T&amp; value);
-T   template&lt;class ForwardIterator, class Predicate&gt;
-      ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
-                                Predicate pred);
-T   template&lt;class InputIterator, class OutputIterator, class T&gt;
-      OutputIterator remove_copy(InputIterator first, InputIterator last,
-                                 OutputIterator result, const T&amp; value);
-T   template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
-      OutputIterator remove_copy_if(InputIterator first, InputIterator last,
-                                    OutputIterator result, Predicate pred);
-T   template&lt;class ForwardIterator&gt;
-      ForwardIterator unique(ForwardIterator first, ForwardIterator last);
-T   template&lt;class ForwardIterator, class BinaryPredicate&gt;
-      ForwardIterator unique(ForwardIterator first, ForwardIterator last,
-                             BinaryPredicate pred);
-T   template&lt;class InputIterator, class OutputIterator&gt;
-      OutputIterator unique_copy(InputIterator first, InputIterator last,
-                                 OutputIterator result);
-T   template&lt;class InputIterator, class OutputIterator, class BinaryPredicate&gt;
-      OutputIterator unique_copy(InputIterator first, InputIterator last,
-                                 OutputIterator result, BinaryPredicate pred);
-T   template&lt;class BidirectionalIterator&gt;
-      void reverse(BidirectionalIterator first, BidirectionalIterator last);
-T   template&lt;class BidirectionalIterator, class OutputIterator&gt;
-      OutputIterator reverse_copy(BidirectionalIterator first,
-                                  BidirectionalIterator last,
-                                  OutputIterator result);
-
-T   template&lt;class ForwardIterator&gt;
-      void rotate(ForwardIterator first, ForwardIterator middle,
-                  ForwardIterator last);
-T   template&lt;class ForwardIterator, class OutputIterator&gt;
-      OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle,
-                                 ForwardIterator last, OutputIterator result);
-T   template&lt;class RandomAccessIterator&gt;
-      void random_shuffle(RandomAccessIterator first,
-                          RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class RandomNumberGenerator&gt;
-      void random_shuffle(RandomAccessIterator first,
-                          RandomAccessIterator last,
-                          RandomNumberGenerator&amp; rand);
-    // _lib.alg.partitions_, partitions:
-T   template&lt;class BidirectionalIterator, class Predicate&gt;
-      BidirectionalIterator partition(BidirectionalIterator first,
-                                      BidirectionalIterator last,
-                                      Predicate pred);
-T   template&lt;class BidirectionalIterator, class Predicate&gt;
-      BidirectionalIterator stable_partition(BidirectionalIterator first,
-                                             BidirectionalIterator last,
-                                             Predicate pred);
-    // _lib.alg.sorting_, sorting and related operations:
-    // _lib.alg.sort_, sorting:
-T   template&lt;class RandomAccessIterator&gt;
-      void sort(RandomAccessIterator first, RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void sort(RandomAccessIterator first, RandomAccessIterator last,
-                Compare comp);
-T   template&lt;class RandomAccessIterator&gt;
-      void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
-                       Compare comp);
-T   template&lt;class RandomAccessIterator&gt;
-      void partial_sort(RandomAccessIterator first,
-                        RandomAccessIterator middle,
-                        RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void partial_sort(RandomAccessIterator first,
-                        RandomAccessIterator middle,
-                        RandomAccessIterator last, Compare comp);
-T   template&lt;class InputIterator, class RandomAccessIterator&gt;
-      RandomAccessIterator
-        partial_sort_copy(InputIterator first, InputIterator last,
-                          RandomAccessIterator result_first,
-                          RandomAccessIterator result_last);
-T   template&lt;class InputIterator, class RandomAccessIterator, class Compare&gt;
-      RandomAccessIterator
-        partial_sort_copy(InputIterator first, InputIterator last,
-                          RandomAccessIterator result_first,
-                          RandomAccessIterator result_last,
-                          Compare comp);
-
-T   template&lt;class RandomAccessIterator&gt;
-      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                       RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
-                       RandomAccessIterator last, Compare comp);
-    // _lib.alg.binary.search_, binary search:
-T   template&lt;class ForwardIterator, class T&gt;
-      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                                  const T&amp; value);
-T   template&lt;class ForwardIterator, class T, class Compare&gt;
-      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
-                                  const T&amp; value, Compare comp);
-T   template&lt;class ForwardIterator, class T&gt;
-      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                                  const T&amp; value);
-T   template&lt;class ForwardIterator, class T, class Compare&gt;
-      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
-                                  const T&amp; value, Compare comp);
-T   template&lt;class ForwardIterator, class T&gt;
-      pair&lt;ForwardIterator, ForwardIterator&gt;
-        equal_range(ForwardIterator first, ForwardIterator last,
-                    const T&amp; value);
-T   template&lt;class ForwardIterator, class T, class Compare&gt;
-      pair&lt;ForwardIterator, ForwardIterator&gt;
-        equal_range(ForwardIterator first, ForwardIterator last,
-                    const T&amp; value, Compare comp);
-T   template&lt;class ForwardIterator, class T&gt;
-      bool binary_search(ForwardIterator first, ForwardIterator last,
-                         const T&amp; value);
-T   template&lt;class ForwardIterator, class T, class Compare&gt;
-      bool binary_search(ForwardIterator first, ForwardIterator last,
-                         const T&amp; value, Compare comp);
-    // _lib.alg.merge_, merge:
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
-      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                           InputIterator2 first2, InputIterator2 last2,
-                           OutputIterator result);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare&gt;
-      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
-                           InputIterator2 first2, InputIterator2 last2,
-                           OutputIterator result, Compare comp);
-T   template&lt;class BidirectionalIterator&gt;
-      void inplace_merge(BidirectionalIterator first,
-                         BidirectionalIterator middle,
-                         BidirectionalIterator last);
-T   template&lt;class BidirectionalIterator, class Compare&gt;
-      void inplace_merge(BidirectionalIterator first,
-                         BidirectionalIterator middle,
-                         BidirectionalIterator last, Compare comp);
-
-    // _lib.alg.set.operations_, set operations:
-T   template&lt;class InputIterator1, class InputIterator2&gt;
-      bool includes(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, InputIterator2 last2);
-T   template&lt;class InputIterator1, class InputIterator2, class Compare&gt;
-      bool includes(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, InputIterator2 last2, Compare comp);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
-      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, InputIterator2 last2,
-                               OutputIterator result);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare&gt;
-      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
-                               InputIterator2 first2, InputIterator2 last2,
-                               OutputIterator result, Compare comp);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
-      OutputIterator set_intersection
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           OutputIterator result);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare&gt;
-      OutputIterator set_intersection
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           OutputIterator result, Compare comp);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
-      OutputIterator set_difference
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           OutputIterator result);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
-             class Compare&gt;
-      OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
-                                    InputIterator2 first2, InputIterator2 last2,
-                                    OutputIterator result, Compare comp);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
-      OutputIterator
-        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                                 InputIterator2 first2, InputIterator2 last2,
-                                 OutputIterator result);
-T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
-              class Compare&gt;
-      OutputIterator
-        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
-                                 InputIterator2 first2, InputIterator2 last2,
-                                 OutputIterator result, Compare comp);
-    // _lib.alg.heap.operations_, heap operations:
-T   template&lt;class RandomAccessIterator&gt;
-      void push_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void push_heap(RandomAccessIterator first, RandomAccessIterator last,
-                     Compare comp);
-
-T   template&lt;class RandomAccessIterator&gt;
-      void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
-                    Compare comp);
-T   template&lt;class RandomAccessIterator&gt;
-      void make_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void make_heap(RandomAccessIterator first, RandomAccessIterator last,
-                     Compare comp);
-T   template&lt;class RandomAccessIterator&gt;
-      void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
-T   template&lt;class RandomAccessIterator, class Compare&gt;
-      void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
-                     Compare comp);
-    // _lib.alg.min.max_, minimum and maximum:
-T   template&lt;class T&gt; const T&amp; min(const T&amp; a, const T&amp; b);
-T   template&lt;class T, class Compare&gt;
-      const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);
-T   template&lt;class T&gt; const T&amp; max(const T&amp; a, const T&amp; b);
-T   template&lt;class T, class Compare&gt;
-      const T&amp; max(const T&amp; a, const T&amp; b, Compare comp);
-T   template&lt;class ForwardIterator&gt;
-      ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
-T   template&lt;class ForwardIterator, class Compare&gt;
-      ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
-                                Compare comp);
-T   template&lt;class ForwardIterator&gt;
-      ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
-T   template&lt;class ForwardIterator, class Compare&gt;
-      ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
-                                Compare comp);
-T   template&lt;class InputIterator1, class InputIterator2&gt;
-      bool lexicographical_compare
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2);
-T   template&lt;class InputIterator1, class InputIterator2, class Compare&gt;
-      bool lexicographical_compare
-          (InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2,
-           Compare comp);
-
-    // _lib.alg.permutation.generators_, permutations
-T   template&lt;class BidirectionalIterator&gt;
-      bool next_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last);
-T   template&lt;class BidirectionalIterator, class Compare&gt;
-      bool next_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last, Compare comp);
-T   template&lt;class BidirectionalIterator&gt;
-      bool prev_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last);
-T   template&lt;class BidirectionalIterator, class Compare&gt;
-      bool prev_permutation(BidirectionalIterator first,
-                            BidirectionalIterator last, Compare comp);
-
-
-   25.4  C library algorithms                         [lib.alg.c.library]
-
-   1 Header &lt;cstdlib&gt; (partial, Table 2):
-
-                    Table 2--Header &lt;cstdlib&gt; synopsis
-
-                      Functions:   bsearch   qsort
-
-
-X  extern "C" void *bsearch(const void *key, const void *base,
-                          size_t nmemb, size_t size,
-                          int (*compar)(const void *, const void *));
-X  extern "C++" void *bsearch(const void *key, const void *base,
-                          size_t nmemb, size_t size,
-                          int (*compar)(const void *, const void *));
-
-X  extern "C" void qsort(void* base, size_t nmemb, size_t size,
-                  int (*compar)(const void*, const void*));
-X  extern "C++" void qsort(void* base, size_t nmemb, size_t size,
-                  int (*compar)(const void*, const void*));
-
-
-
-   26.2  Complex numbers                            [lib.complex.numbers]
-
-
-   26.2.1  Header &lt;complex&gt; synopsis               [lib.complex.synopsis]
-
-T   template&lt;class T&gt; class complex;
-T   template&lt;&gt; class complex&lt;float&gt;;
-T   template&lt;&gt; class complex&lt;double&gt;;
-T   template&lt;&gt; class complex&lt;long double&gt;;
-    // _lib.complex.ops_ operators:
-T   template&lt;class T&gt;
-      complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const T&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator-
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const T&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator*
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const T&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator/
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const T&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; bool operator==
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; bool operator==(const T&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; bool operator!=(const T&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T, class charT, class traits&gt;
-      basic_istream&lt;charT, traits&gt;&amp;
-      operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;, complex&lt;T&gt;&amp;);
-
-T   template&lt;class T, class charT, class traits&gt;
-      basic_ostream&lt;charT, traits&gt;&amp;
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;, const complex&lt;T&gt;&amp;);
-    // _lib.complex.value.ops_ values:
-T   template&lt;class T&gt; T real(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; T imag(const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt; T abs(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; T arg(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; T norm(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; conj(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; polar(const T&amp;, const T&amp;);
-    // _lib.complex.transcendentals_ transcendentals:
-T   template&lt;class T&gt; complex&lt;T&gt; cos  (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; cosh (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; exp  (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; log  (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; log10(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, int);
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; pow(const T&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; sin  (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; sinh (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; sqrt (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; tan  (const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; tanh (const complex&lt;T&gt;&amp;);
-   }
-
-   26.2.2  Template class complex                           [lib.complex]
-
-    template&lt;class T&gt;
-T   class complex {
-    public:
-T     typedef T value_type;
-
-T     complex(const T&amp; re = T(), const T&amp; im = T());
-T     complex(const complex&amp;);
-T     template&lt;class X&gt; complex(const complex&lt;X&gt;&amp;);
-
-T     T real() const;
-T     T imag() const;
-
-T     complex&lt;T&gt;&amp; operator= (const T&amp;);
-T     complex&lt;T&gt;&amp; operator+=(const T&amp;);
-T     complex&lt;T&gt;&amp; operator-=(const T&amp;);
-T     complex&lt;T&gt;&amp; operator*=(const T&amp;);
-T     complex&lt;T&gt;&amp; operator/=(const T&amp;);
-
-T     complex&amp; operator=(const complex&amp;);
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
-    };
-
-T   template&lt;class T&gt; complex&lt;T&gt; operator+
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const T&amp;, const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt; complex&lt;T&gt; operator-
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const T&amp;, const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt; complex&lt;T&gt; operator*
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator*(const T&amp;, const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt; complex&lt;T&gt; operator/
-      (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator/(const T&amp;, const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; bool operator==(const T&amp;, const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
-T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; bool operator!=(const T&amp;, const complex&lt;T&gt;&amp;);
-
-T   template&lt;class T, class charT, class traits&gt;
-      basic_istream&lt;charT, traits&gt;&amp;
-      operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;, complex&lt;T&gt;&amp;);
-
-T   template&lt;class T, class charT, class traits&gt;
-      basic_ostream&lt;charT, traits&gt;&amp;
-      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;, const complex&lt;T&gt;&amp;);
-
-
-   26.2.3  complex specializations                  [lib.complex.special]
-
-T   template&lt;&gt; class complex&lt;float&gt; {
-    public:
-T     typedef float value_type;
-
-T     complex(float re = 0.0f, float im = 0.0f);
-T     explicit complex(const complex&lt;double&gt;&amp;);
-T     explicit complex(const complex&lt;long double&gt;&amp;);
-T     float real() const;
-T     float imag() const;
-
-T     complex&lt;float&gt;&amp; operator= (float);
-T     complex&lt;float&gt;&amp; operator+=(float);
-T     complex&lt;float&gt;&amp; operator-=(float);
-T     complex&lt;float&gt;&amp; operator*=(float);
-T     complex&lt;float&gt;&amp; operator/=(float);
-
-T     complex&lt;float&gt;&amp; operator=(const complex&lt;float&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
-    };
-T   template&lt;&gt; class complex&lt;double&gt; {
-    public:
-T     typedef double value_type;
-
-T     complex(double re = 0.0, double im = 0.0);
-T     complex(const complex&lt;float&gt;&amp;);
-T     explicit complex(const complex&lt;long double&gt;&amp;);
-T     double real() const;
-T     double imag() const;
-
-T     complex&lt;double&gt;&amp; operator= (double);
-T     complex&lt;double&gt;&amp; operator+=(double);
-T     complex&lt;double&gt;&amp; operator-=(double);
-T     complex&lt;double&gt;&amp; operator*=(double);
-T     complex&lt;double&gt;&amp; operator/=(double);
-
-T     complex&lt;double&gt;&amp; operator=(const complex&lt;double&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
-    };
-
-T   template&lt;&gt; class complex&lt;long double&gt; {
-    public:
-T     typedef long double value_type;
-
-T     complex(long double re = 0.0L, long double im = 0.0L);
-T     complex(const complex&lt;float&gt;&amp;);
-T     complex(const complex&lt;double&gt;&amp;);
-T     long double real() const;
-T     long double imag() const;
-
-T     complex&lt;long double&gt;&amp; operator=(const complex&lt;long double&gt;&amp;);
-T     complex&lt;long double&gt;&amp; operator= (long double);
-T     complex&lt;long double&gt;&amp; operator+=(long double);
-T     complex&lt;long double&gt;&amp; operator-=(long double);
-T     complex&lt;long double&gt;&amp; operator*=(long double);
-T     complex&lt;long double&gt;&amp; operator/=(long double);
-
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
-T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
-    };
-
-   26.3  Numeric arrays                                    [lib.numarray]
-
-   26.3.1  Header &lt;valarray&gt; synopsis             [lib.valarray.synopsis]
-
-T   template&lt;class T&gt; class valarray;         // An array of type T
-T   class slice;
-T   template&lt;class T&gt; class slice_array;
-T   class gslice;
-T   template&lt;class T&gt; class gslice_array;
-T   template&lt;class T&gt; class mask_array;       // a masked array
-T   template&lt;class T&gt; class indirect_array;   // an indirected array
-
-T   template&lt;class T&gt; valarray&lt;T&gt; operator*
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator* (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator* (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator/
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator/ (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator/ (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator%
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator% (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator% (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator+
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator+ (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator+ (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator-
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator- (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator- (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator^
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator^ (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator^ (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp;
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator|
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator| (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator| (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator||
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator||(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator||(const T&amp;, const valarray&lt;T&gt;&amp;);
-
-T   template&lt;class T&gt;
-      valarray&lt;bool&gt; operator==(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator==(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator==(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt;
-      valarray&lt;bool&gt; operator!=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator!=(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator!=(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt;
-      valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt;
-      valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt;
-      valarray&lt;bool&gt; operator&lt;=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;=(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;=(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt;
-      valarray&lt;bool&gt; operator&gt;=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;=(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;=(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; abs  (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; acos (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; asin (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; atan (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; atan2
-      (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; atan2(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; atan2(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; cos  (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; cosh (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; exp  (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; log  (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; log10(const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const T&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; pow(const T&amp;, const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; sin  (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; sinh (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; sqrt (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; tan  (const valarray&lt;T&gt;&amp;);
-T   template&lt;class T&gt; valarray&lt;T&gt; tanh (const valarray&lt;T&gt;&amp;);
-   }
-
-
-   26.3.2  Template class valarray                [lib.template.valarray]
-
-T   template&lt;class T&gt; class valarray {
-    public:
-T     typedef T value_type;
-
-      // _lib.valarray.cons_ construct/destroy:
-T     valarray();
-T     explicit valarray(size_t);
-T     valarray(const T&amp;, size_t);
-T     valarray(const T*, size_t);
-T     valarray(const valarray&amp;);
-T     valarray(const slice_array&lt;T&gt;&amp;);
-T     valarray(const gslice_array&lt;T&gt;&amp;);
-T     valarray(const mask_array&lt;T&gt;&amp;);
-T     valarray(const indirect_array&lt;T&gt;&amp;);
-T    ~valarray();
-
-      // _lib.valarray.assign_ assignment:
-T     valarray&lt;T&gt;&amp; operator=(const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator=(const T&amp;);
-T     valarray&lt;T&gt;&amp; operator=(const slice_array&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator=(const gslice_array&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator=(const mask_array&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator=(const indirect_array&lt;T&gt;&amp;);
-      // _lib.valarray.access_ element access:
-T     T                 operator[](size_t) const;
-T     T&amp;                operator[](size_t);
-      // _lib.valarray.sub_ subset operations:
-T     valarray&lt;T&gt;       operator[](slice) const;
-T     slice_array&lt;T&gt;    operator[](slice);
-T     valarray&lt;T&gt;       operator[](const gslice&amp;) const;
-T     gslice_array&lt;T&gt;   operator[](const gslice&amp;);
-T     valarray&lt;T&gt;       operator[](const valarray&lt;bool&gt;&amp;) const;
-T     mask_array&lt;T&gt;     operator[](const valarray&lt;bool&gt;&amp;);
-T     valarray&lt;T&gt;       operator[](const valarray&lt;size_t&gt;&amp;) const;
-T     indirect_array&lt;T&gt; operator[](const valarray&lt;size_t&gt;&amp;);
-      // _lib.valarray.unary_ unary operators:
-T     valarray&lt;T&gt; operator+() const;
-T     valarray&lt;T&gt; operator-() const;
-T     valarray&lt;T&gt; operator~() const;
-T     valarray&lt;T&gt; operator!() const;
-      // _lib.valarray.cassign_ computed assignment:
-T     valarray&lt;T&gt;&amp; operator*= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator/= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator%= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator+= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator-= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator^= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator&amp;= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator|= (const T&amp;);
-T     valarray&lt;T&gt;&amp; operator&lt;&lt;=(const T&amp;);
-T     valarray&lt;T&gt;&amp; operator&gt;&gt;=(const T&amp;);
-T     valarray&lt;T&gt;&amp; operator*= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator/= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator%= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator+= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator-= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator^= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator|= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator&amp;= (const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator&lt;&lt;=(const valarray&lt;T&gt;&amp;);
-T     valarray&lt;T&gt;&amp; operator&gt;&gt;=(const valarray&lt;T&gt;&amp;);
-      // _lib.valarray.members_ member functions:
-T     size_t size() const;
-T     T    sum() const;
-T     T    min() const;
-T     T    max() const;
-
-T     valarray&lt;T&gt; shift (int) const;
-T     valarray&lt;T&gt; cshift(int) const;
-T     valarray&lt;T&gt; apply(T func(T)) const;
-T     valarray&lt;T&gt; apply(T func(const T&amp;)) const;
-T     void resize(size_t sz, T c = T());
-    };
-   }
-
-
-
-   26.3.4  Class slice                                  [lib.class.slice]
-
-T   class slice {
-    public:
-T     slice();
-T     slice(size_t, size_t, size_t);
-
-T     size_t start() const;
-T     size_t size() const;
-T     size_t stride() const;
-    };
-   }
-
-
-
-   26.3.5  Template class slice_array          [lib.template.slice.array]
-
-T   template &lt;class T&gt; class slice_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator=(const T&amp;);
-T    ~slice_array();
-    private:
-T     slice_array();
-T     slice_array(const slice_array&amp;);
-T     slice_array&amp; operator=(const slice_array&amp;);
-    };
-   }
-
-
-
-   26.3.6  The gslice class                            [lib.class.gslice]
-
-T   class gslice {
-    public:
-T     gslice();
-T     gslice(size_t s, const valarray&lt;size_t&gt;&amp; l, const valarray&lt;size_t&gt;&amp; d);
-
-T     size_t           start() const;
-T     valarray&lt;size_t&gt; size() const;
-T     valarray&lt;size_t&gt; stride() const;
-    };
-
-
-   26.3.7  Template class gslice_array        [lib.template.gslice.array]
-
-T   template &lt;class T&gt; class gslice_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator=(const T&amp;);
-T    ~gslice_array();
-    private:
-T     gslice_array();
-T     gslice_array(const gslice_array&amp;);
-T     gslice_array&amp; operator=(const gslice_array&amp;);
-    };
-
-
-   26.3.8  Template class mask_array            [lib.template.mask.array]
-
-T   template &lt;class T&gt; class mask_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator=(const T&amp;);
-T    ~mask_array();
-    private:
-T     mask_array();
-T     mask_array(const mask_array&amp;);
-T     mask_array&amp; operator=(const mask_array&amp;);
-      //  remainder implementation defined
-    };
-
-
-   26.3.9  Template class                   [lib.template.indirect.array]
-       indirect_array
-
-T   template &lt;class T&gt; class indirect_array {
-    public:
-T     typedef T value_type;
-
-T     void operator=  (const valarray&lt;T&gt;&amp;) const;
-T     void operator*= (const valarray&lt;T&gt;&amp;) const;
-T     void operator/= (const valarray&lt;T&gt;&amp;) const;
-T     void operator%= (const valarray&lt;T&gt;&amp;) const;
-T     void operator+= (const valarray&lt;T&gt;&amp;) const;
-T     void operator-= (const valarray&lt;T&gt;&amp;) const;
-T     void operator^= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
-T     void operator|= (const valarray&lt;T&gt;&amp;) const;
-T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
-T     void operator=(const T&amp;);
-T    ~indirect_array();
-    private:
-T     indirect_array();
-T     indirect_array(const indirect_array&amp;);
-T     indirect_array&amp; operator=(const indirect_array&amp;);
-      //  remainder implementation defined
-    };
-
-   26.4  Generalized numeric operations                 [lib.numeric.ops]
-
-   Header &lt;numeric&gt; synopsis
-
-T   template &lt;class InputIterator, class T&gt;
-      T accumulate(InputIterator first, InputIterator last, T init);
-
-T   template &lt;class InputIterator, class T, class BinaryOperation&gt;
-      T accumulate(InputIterator first, InputIterator last, T init,
-                   BinaryOperation binary_op);
-
-T   template &lt;class InputIterator1, class InputIterator2, class T&gt;
-      T inner_product(InputIterator1 first1, InputIterator1 last1,
-                      InputIterator2 first2, T init);
-
-T   template &lt;class InputIterator1, class InputIterator2, class T,
-              class BinaryOperation1, class BinaryOperation2&gt;
-      T inner_product(InputIterator1 first1, InputIterator1 last1,
-                      InputIterator2 first2, T init,
-                      BinaryOperation1 binary_op1,
-                      BinaryOperation2 binary_op2);
-
-T   template &lt;class InputIterator, class OutputIterator&gt;
-      OutputIterator partial_sum(InputIterator first,
-                                 InputIterator last,
-                                 OutputIterator result);
-
-T   template &lt;class InputIterator, class OutputIterator,
-              class BinaryOperation&gt;
-      OutputIterator partial_sum(InputIterator first,
-                                 InputIterator last,
-                                 OutputIterator result,
-                                 BinaryOperation binary_op);
-
-T   template &lt;class InputIterator, class OutputIterator&gt;
-      OutputIterator adjacent_difference(InputIterator first,
-                                         InputIterator last,
-                                         OutputIterator result);
-
-T   template &lt;class InputIterator, class OutputIterator,
-              class BinaryOperation&gt;
-      OutputIterator adjacent_difference(InputIterator first,
-                                         InputIterator last,
-                                         OutputIterator result,
-                                         BinaryOperation binary_op);
-
-
-   26.5  C Library                                           [lib.c.math]
-
-                     Table 2--Header &lt;cmath&gt; synopsis
-X               Macro:   HUGE_VAL
-                Functions:
-X               acos     cos        fmod    modf   tan
-X               asin     cosh       frexp   pow    tanh
-X               atan     exp        ldexp   sin
-X               atan2    fabs       log     sinh
-X               ceil     floor      log10   sqrt
-
-                    Table 3--Header &lt;cstdlib&gt; synopsis
-X                     Macros:   RAND_MAX
-X                     Types:    div_t      ldiv_t
-                      Functions:
-X                     abs       labs       srand
-X                     div       ldiv       rand
-
-X  long   abs(long);               // labs()
-X  ldiv_t div(long, long);         // ldiv()
-
-X  float abs  (float);
-X  float acos (float);
-X  float asin (float);
-X  float atan (float);
-X  float atan2(float, float);
-X  float ceil (float);
-X  float cos  (float);
-X  float cosh (float);
-X  float exp  (float);
-X  float fabs (float);
-X  float floor(float);
-X  float fmod (float, float);
-X  float frexp(float, int*);
-X  float ldexp(float, int);
-X  float log  (float);
-X  float log10(float);
-X  float modf (float, float*);
-X  float pow  (float, float);
-X  float pow  (float, int);
-X  float sin  (float);
-X  float sinh (float);
-X  float sqrt (float);
-X  float tan  (float);
-X  float tanh (float);
-
-X  double abs(double);            // fabs()
-X  double pow(double, int);
-
-X  long double abs  (long double);
-X  long double acos (long double);
-X  long double asin (long double);
-X  long double atan (long double);
-X  long double atan2(long double, long double);
-X  long double ceil (long double);
-X  long double cos  (long double);
-X  long double cosh (long double);
-X  long double exp  (long double);
-X  long double fabs (long double);
-X  long double floor(long double);
-X  long double fmod (long double, long double);
-X  long double frexp(long double, int*);
-X  long double ldexp(long double, int);
-X  long double log  (long double);
-X  long double log10(long double);
-X  long double modf (long double, long double*);
-X  long double pow  (long double, long double);
-X  long double pow  (long double, int);
-X  long double sin  (long double);
-X  long double sinh (long double);
-X  long double sqrt (long double);
-X  long double tan  (long double);
-X  long double tanh (long double);
-
-   Header &lt;iosfwd&gt; synopsis
-
-X   template&lt;class charT&gt; class char_traits;
-X   template&lt;&gt; class char_traits&lt;char&gt;;
-X   template&lt;&gt; class char_traits&lt;wchar_t&gt;;
-X   template&lt;class T&gt; class allocator;
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ios;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_streambuf;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_istream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ostream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_iostream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-      class basic_stringbuf;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-      class basic_istringstream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-      class basic_ostringstream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-      class basic_stringstream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_filebuf;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ifstream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ofstream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_fstream;
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class istreambuf_iterator;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class ostreambuf_iterator;
-X   typedef basic_ios&lt;char&gt;       ios;
-X   typedef basic_ios&lt;wchar_t&gt;    wios;
-X   typedef basic_streambuf&lt;char&gt; streambuf;
-X   typedef basic_istream&lt;char&gt;   istream;
-X   typedef basic_ostream&lt;char&gt;   ostream;
-X   typedef basic_iostream&lt;char&gt;  iostream;
-X   typedef basic_stringbuf&lt;char&gt;     stringbuf;
-X   typedef basic_istringstream&lt;char&gt; istringstream;
-X   typedef basic_ostringstream&lt;char&gt; ostringstream;
-X   typedef basic_stringstream&lt;char&gt;  stringstream;
-X   typedef basic_filebuf&lt;char&gt;  filebuf;
-X   typedef basic_ifstream&lt;char&gt; ifstream;
-X   typedef basic_ofstream&lt;char&gt; ofstream;
-X   typedef basic_fstream&lt;char&gt;  fstream;
-X   typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;
-X   typedef basic_istream&lt;wchar_t&gt;   wistream;
-X   typedef basic_ostream&lt;wchar_t&gt;   wostream;
-X   typedef basic_iostream&lt;wchar_t&gt;  wiostream;
-X   typedef basic_stringbuf&lt;wchar_t&gt;     wstringbuf;
-X   typedef basic_istringstream&lt;wchar_t&gt; wistringstream;
-X   typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;
-X   typedef basic_stringstream&lt;wchar_t&gt;  wstringstream;
-
-X   typedef basic_filebuf&lt;wchar_t&gt;  wfilebuf;
-X   typedef basic_ifstream&lt;wchar_t&gt; wifstream;
-X   typedef basic_ofstream&lt;wchar_t&gt; wofstream;
-X   typedef basic_fstream&lt;wchar_t&gt;  wfstream;
-X   template &lt;class state&gt; class fpos;
-X   typedef fpos&lt;char_traits&lt;char&gt;::state_type&gt;    streampos;
-X   typedef fpos&lt;char_traits&lt;wchar_t&gt;::state_type&gt; wstreampos;
-
-   27.3  Standard iostream objects                 [lib.iostream.objects]
-
-   Header &lt;iostream&gt; synopsis
-
-T  [must also include &lt;istream&gt; and &lt;ostream&gt;]
-T   extern istream cin;
-T   extern ostream cout;
-T   extern ostream cerr;
-T   extern ostream clog;
-
-T   extern wistream wcin;
-T   extern wostream wcout;
-T   extern wostream wcerr;
-T   extern wostream wclog;
-
-   27.4  Iostreams base classes                      [lib.iostreams.base]
-
-   Header &lt;ios&gt; synopsis
-
-   #include &lt;iosfwd&gt;
-
-T   typedef OFF_T  streamoff;
-T   typedef SZ_T streamsize;
-T   template &lt;class stateT&gt; class fpos;
-
-    class ios_base;
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ios;
-   // _lib.std.ios.manip_, manipulators:
-T   ios_base&amp; boolalpha  (ios_base&amp; str);
-T   ios_base&amp; noboolalpha(ios_base&amp; str);
-T   ios_base&amp; showbase   (ios_base&amp; str);
-T   ios_base&amp; noshowbase (ios_base&amp; str);
-T   ios_base&amp; showpoint  (ios_base&amp; str);
-T   ios_base&amp; noshowpoint(ios_base&amp; str);
-T   ios_base&amp; showpos    (ios_base&amp; str);
-T   ios_base&amp; noshowpos  (ios_base&amp; str);
-T   ios_base&amp; skipws     (ios_base&amp; str);
-T   ios_base&amp; noskipws   (ios_base&amp; str);
-T   ios_base&amp; nouppercase(ios_base&amp; str);
-T   ios_base&amp; uppercase  (ios_base&amp; str);
-M   ios_base&amp; unitbuf    (ios_base&amp; str);
-M   ios_base&amp; nounitbuf  (ios_base&amp; str);
-   // _lib.adjustfield.manip_ adjustfield:
-T   ios_base&amp; internal   (ios_base&amp; str);
-T   ios_base&amp; left       (ios_base&amp; str);
-T   ios_base&amp; right      (ios_base&amp; str);
-   // _lib.basefield.manip_ basefield:
-T   ios_base&amp; dec        (ios_base&amp; str);
-T   ios_base&amp; hex        (ios_base&amp; str);
-T   ios_base&amp; oct        (ios_base&amp; str);
-
-   // _lib.floatfield.manip_ floatfield:
-T   ios_base&amp; fixed      (ios_base&amp; str);
-T   ios_base&amp; scientific (ios_base&amp; str);
-
-
-   27.4.2  Class ios_base                                  [lib.ios.base]
-
-T   class ios_base {
-    public:
-      class failure;
-T     typedef T1 fmtflags;
-T     static const fmtflags boolalpha;
-T     static const fmtflags dec;
-T     static const fmtflags fixed;
-T     static const fmtflags hex;
-T     static const fmtflags internal;
-T     static const fmtflags left;
-T     static const fmtflags oct;
-T     static const fmtflags right;
-T     static const fmtflags scientific;
-T     static const fmtflags showbase;
-T     static const fmtflags showpoint;
-T     static const fmtflags showpos;
-T     static const fmtflags skipws;
-X     static const fmtflags unitbuf;
-T     static const fmtflags uppercase;
-T     static const fmtflags adjustfield;
-T     static const fmtflags basefield;
-T     static const fmtflags floatfield;
-
-      typedef T2 iostate;
-T     static const iostate badbit;
-T     static const iostate eofbit;
-T     static const iostate failbit;
-T     static const iostate goodbit;
-T     typedef T3 openmode;
-T     static const openmode app;
-T     static const openmode ate;
-T     static const openmode binary;
-T     static const openmode in;
-T     static const openmode out;
-T     static const openmode trunc;
-T     typedef T4 seekdir;
-T     static const seekdir beg;
-T     static const seekdir cur;
-T     static const seekdir end;
-T     class Init;
-      // _lib.fmtflags.state_ fmtflags state:
-T     fmtflags flags() const;
-T     fmtflags flags(fmtflags fmtfl);
-T     fmtflags setf(fmtflags fmtfl);
-T     fmtflags setf(fmtflags fmtfl, fmtflags mask);
-T     void unsetf(fmtflags mask);
-T     streamsize precision() const;
-T     streamsize precision(streamsize prec);
-T     streamsize width() const;
-T     streamsize width(streamsize wide);
-      // _lib.ios.base.locales_ locales:
-T     locale imbue(const locale&amp; loc);
-T     locale getloc() const;
-      // _lib.ios.base.storage_ storage:
-T     static int xalloc();
-T     long&amp;  iword(int index);
-T     void*&amp; pword(int index);
-      // destructor
-T     virtual ~ios_base();
-      // _lib.ios.base.callback_ callbacks;
-T     enum event { erase_event, imbue_event, copyfmt_event };
-T     typedef void (*event_callback)(event, ios_base&amp;, int index);
-T     void register_callback(event_call_back fn, int index);
-T     static bool sync_with_stdio(bool sync = true);
-    protected:
-T     ios_base();
-    };
-
-   27.4.2.1.1  Class ios_base::failure                 [lib.ios::failure]
-
-T   class ios_base::failure : public exception {
-    public:
-T     explicit failure(const string&amp; msg);
-T     virtual ~failure();
-T     virtual const char* what() const throw();
-    };
-
-
-   27.4.2.1.6  Class ios_base::Init                       [lib.ios::Init]
-
-T   class ios_base::Init {
-    public:
-T     Init();
-T    ~Init();
-    };
-
-
-   27.4.3  Template class fpos                                 [lib.fpos]
-
-X   template &lt;class stateT&gt; class fpos {
-    public:
-      // _lib.fpos.members_ Members
-T     stateT state() const;
-T     void state(stateT);
-    private;
-T     stateT st; // exposition only
-    };
-
-
-   27.4.5  Template class basic_ios                             [lib.ios]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-X   class basic_ios : public ios_base {
-    public:
-
-      // Types:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-T     operator void*() const
-T     bool operator!() const
-T     iostate rdstate() const;
-T     void clear(iostate state = goodbit);
-T     void setstate(iostate state);
-T     bool good() const;
-T     bool eof()  const;
-T     bool fail() const;
-T     bool bad()  const;
-T     iostate exceptions() const;
-T     void exceptions(iostate except);
-      // _lib.basic.ios.cons_ Constructor/destructor:
-T     explicit basic_ios(basic_streambuf&lt;charT,traits&gt;* sb);
-T     virtual ~basic_ios();
-      // _lib.basic.ios.members_ Members:
-T     basic_ostream&lt;charT,traits&gt;* tie() const;
-T     basic_ostream&lt;charT,traits&gt;* tie(basic_ostream&lt;charT,traits&gt;* tiestr);
-T     basic_streambuf&lt;charT,traits&gt;* rdbuf() const;
-T     basic_streambuf&lt;charT,traits&gt;* rdbuf(basic_streambuf&lt;charT,traits&gt;* sb);
-X     basic_ios&amp; copyfmt(const basic_ios&amp; rhs);
-T     char_type fill() const;
-T     char_type fill(char_type ch);
-      // _lib.ios.base.locales_ locales:
-T     locale imbue(const locale&amp; loc);
-X     char     narrow(char_type c, char dfault) const;
-X     char_type widen(char c) const;
-    protected:
-      basic_ios();
-T     void init(basic_streambuf&lt;charT,traits&gt;* sb);
-   private:
-T     basic_ios(const basic_ios&amp; );       // not defined
-T     basic_ios&amp; operator=(const basic_ios&amp;);     // not defined
-    };
-
-
-   27.5  Stream buffers                              [lib.stream.buffers]
-
-   Header &lt;streambuf&gt; synopsis
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_streambuf;
-T   typedef basic_streambuf&lt;char&gt;     streambuf;
-T   typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;
-
-   27.5.2  Template class                                 [lib.streambuf]
-       basic_streambuf&lt;charT,traits&gt;
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-X   class basic_streambuf {
-    public:
-
-      // Types:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-T     virtual ~basic_streambuf();
-      // _lib.streambuf.locales_ locales:
-T     locale   pubimbue(const locale &amp;loc);
-T     locale   getloc() const;
-      // _lib.streambuf.buffer_ buffer and positioning:
-T     basic_streambuf&lt;char_type,traits&gt;*
-               pubsetbuf(char_type* s, streamsize n);
-T     pos_type pubseekoff(off_type off, ios_base::seekdir way,
-                          ios_base::openmode which =
-                              ios_base::in | ios_base::out);
-T     pos_type pubseekpos(pos_type sp,
-                          ios_base::openmode which =
-                              ios_base::in | ios_base::out);
-T     int      pubsync();
-
-      // Get and put areas:
-      // _lib.streambuf.pub.get_ Get area:
-T     streamsize in_avail();
-T     int_type snextc();
-T     int_type sbumpc();
-T     int_type sgetc();
-T     streamsize sgetn(char_type* s, streamsize n);
-      // _lib.streambuf.pub.pback_ Putback:
-X     int_type sputbackc(char_type c);
-X     int_type sungetc();
-      // _lib.streambuf.pub.put_ Put area:
-T     int_type   sputc(char_type c);
-X     streamsize sputn(const char_type* s, streamsize n);
-    protected:
-T     basic_streambuf();
-      // _lib.streambuf.get.area_ Get area:
-T     char_type* eback() const;
-T     char_type* gptr()  const;
-T     char_type* egptr() const;
-T     void       gbump(int n);
-T     void       setg(char_type* gbeg, char_type* gnext, char_type* gend);
-      // _lib.streambuf.put.area_ Put area:
-T     char_type* pbase() const;
-T     char_type* pptr() const;
-T     char_type* epptr() const;
-T     void       pbump(int n);
-T     void       setp(char_type* pbeg, char_type* pend);
-      // _lib.streambuf.virtuals_ virtual functions:
-      // _lib.streambuf.virt.locales_ Locales:
-T     virtual void imbue(const locale &amp;loc);
-      // _lib.streambuf.virt.buffer_ Buffer management and positioning:
-T     virtual basic_streambuf&lt;char_type,traits&gt;*
-                       setbuf(char_type* s, streamsize n);
-T     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
-                ios_base::openmode which = ios_base::in | ios_base::out);
-T     virtual pos_type seekpos(pos_type sp,
-                ios_base::openmode which = ios_base::in | ios_base::out);
-T     virtual int      sync();
-      // _lib.streambuf.virt.get_ Get area:
-T     virtual int        showmanyc();
-T     virtual streamsize xsgetn(char_type* s, streamsize n);
-T     virtual int_type   underflow();
-T     virtual int_type   uflow();
-      // _lib.streambuf.virt.pback_ Putback:
-T     virtual int_type   pbackfail(int_type c = traits::eof());
-      // _lib.streambuf.virt.put_ Put area:
-X     virtual streamsize xsputn(const char_type* s, streamsize n);
-T     virtual int_type   overflow (int_type c = traits::eof());
-    };
-
-   27.6  Formatting and manipulators                [lib.iostream.format]
-
-   Header &lt;istream&gt; synopsis
-
-T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_istream;
-T   typedef basic_istream&lt;char&gt;     istream;
-T   typedef basic_istream&lt;wchar_t&gt; wistream;
-
-T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_iostream;
-T   typedef basic_iostream&lt;char&gt;    iostream;
-T   typedef basic_iostream&lt;wchar_t&gt; wiostream;
-
-X   template &lt;class charT, class traits&gt;
-      basic_istream&lt;charT,traits&gt;&amp; ws(basic_istream&lt;charT,traits&gt;&amp; is);
-
-   Header &lt;ostream&gt; synopsis
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ostream;
-T   typedef basic_ostream&lt;char&gt;     ostream;
-T   typedef basic_ostream&lt;wchar_t&gt; wostream;
-
-T   template &lt;class charT, class traits&gt;
-      basic_ostream&lt;charT,traits&gt;&amp; endl(basic_ostream&lt;charT,traits&gt;&amp; os);
-T   template &lt;class charT, class traits&gt;
-      basic_ostream&lt;charT,traits&gt;&amp; ends(basic_ostream&lt;charT,traits&gt;&amp; os);
-T   template &lt;class charT, class traits&gt;
-      basic_ostream&lt;charT,traits&gt;&amp; flush(basic_ostream&lt;charT,traits&gt;&amp; os);
-
-   Header &lt;iomanip&gt; synopsis
-
-      // Types T1, T2, ... are unspecified implementation types
-T     T1 resetiosflags(ios_base::fmtflags mask);
-T     T2 setiosflags  (ios_base::fmtflags mask);
-T     T3 setbase(int base);
-T     template&lt;charT&gt; T4 setfill(charT c);
-T     T5 setprecision(int n);
-T     T6 setw(int n);
-
-
-   27.6.1.1  Template class basic_istream                   [lib.istream]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-T   class basic_istream : virtual public basic_ios&lt;charT,traits&gt; {
-    public:
-    // Types (inherited from basic_ios (_lib.ios_)):
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.istream.cons_ Constructor/destructor:
-T     explicit basic_istream(basic_streambuf&lt;charT,traits&gt;* sb);
-T     virtual ~basic_istream();
-      // _lib.istream::sentry_ Prefix/suffix:
-T     class sentry;
-
-      // _lib.istream.formatted_ Formatted input:
-T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
-          (basic_istream&lt;charT,traits&gt;&amp; (*pf)(basic_istream&lt;charT,traits&gt;&amp;))
-T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
-          (basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;))
-T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
-          (ios_base&amp; (*pf)(ios_base&amp;))
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(bool&amp; n);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(short&amp; n);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned short&amp; n);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(int&amp; n);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned int&amp; n);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long&amp; n);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned long&amp; n);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(float&amp; f);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(double&amp; f);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long double&amp; f);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(void*&amp; p);
-S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
-          (basic_streambuf&lt;char_type,traits&gt;* sb);
-      // _lib.istream.unformatted_ Unformatted input:
-T     streamsize gcount() const;
-S     int_type get();
-S     basic_istream&lt;charT,traits&gt;&amp; get(char_type&amp; c);
-S     basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n);
-S     basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n,
-                        char_type delim);
-S     basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb);
-S     basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb,
-                        char_type delim);
-S     basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n);
-S     basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n,
-                        char_type delim);
-S     basic_istream&lt;charT,traits&gt;&amp; ignore
-          (streamsize n = 1, int_type delim = traits::eof());
-S     int_type                     peek();
-S     basic_istream&lt;charT,traits&gt;&amp; read    (char_type* s, streamsize n);
-S     streamsize                   readsome(char_type* s, streamsize n);
-S     basic_istream&lt;charT,traits&gt;&amp; putback(char_type c);
-S     basic_istream&lt;charT,traits&gt;&amp; unget();
-S     int sync();
-
-S     pos_type tellg();
-S     basic_istream&lt;charT,traits&gt;&amp; seekg(pos_type);
-S     basic_istream&lt;charT,traits&gt;&amp; seekg(off_type, ios_base::seekdir);
-    };
-
-    // _lib.istream::extractors_ character extraction templates:
-S   template&lt;class charT, class traits&gt;
-      basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,
-                                              charT&amp;);
-S   template&lt;class traits&gt;
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
-                                             unsigned char&amp;);
-S   template&lt;class traits&gt;
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
-                                             signed char&amp;);
-
-S   template&lt;class charT, class traits&gt;
-      basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,
-                                              charT*);
-S   template&lt;class traits&gt;
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
-                                             unsigned char*);
-S   template&lt;class traits&gt;
-      basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
-                                             signed char*);
-
-   27.6.1.1.2  Class basic_istream::sentry          [lib.istream::sentry]
-
-
-    template &lt;class charT,class traits = char_traits&lt;charT&gt; &gt;
-S   class basic_istream&lt;charT,traits&gt;::sentry {
-      typedef traits traits_type;
-S     bool ok_; // exposition only
-     public:
-S     explicit sentry(basic_istream&lt;charT,traits&gt;&amp; is, bool noskipws = false);
-S     ~sentry();
-S     operator bool() const { return ok_; }
-     private:
-T     sentry(const sentry&amp;); //   not defined
-T     sentry&amp; operator=(const sentry&amp;); //   not defined
-    };
-
-
-   27.6.1.5  Template class basic_iostream            [lib.iostreamclass]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-T   class basic_iostream :
-      public basic_istream&lt;charT,traits&gt;,
-      public basic_ostream&lt;charT,traits&gt; {
-    public:
-      // constructor/destructor
-T     explicit basic_iostream(basic_streambuf&lt;charT,traits&gt;* sb);
-T     virtual ~basic_iostream();
-    };
-
-
-   27.6.2.1  Template class basic_ostream                   [lib.ostream]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-X   class basic_ostream : virtual public basic_ios&lt;charT,traits&gt; {
-    public:
-    // Types (inherited from basic_ios (_lib.ios_)):
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.ostream.cons_ Constructor/destructor:
-T     explicit basic_ostream(basic_streambuf&lt;char_type,traits&gt;* sb);
-T     virtual ~basic_ostream();
-      // _lib.ostream::sentry_ Prefix/suffix:
-T     class sentry;
-      // _lib.ostream.formatted_ Formatted output:
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
-          (basic_ostream&lt;charT,traits&gt;&amp; (*pf)(basic_ostream&lt;charT,traits&gt;&amp;));
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
-          (basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;));
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
-          (ios_base&amp; (*pf)(ios_base&amp;));
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(bool n);
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(short n);
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned short n);
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(int n);
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned int n);
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long n);
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned long n);
-S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(float f);
-S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(double f);
-S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long double f);
-T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(const void* p);
-X     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
-          (basic_streambuf&lt;char_type,traits&gt;* sb);
-      // _lib.ostream.unformatted_ Unformatted output:
-T     basic_ostream&lt;charT,traits&gt;&amp; put(char_type c);
-T     basic_ostream&lt;charT,traits&gt;&amp; write(const char_type* s, streamsize n);
-X     basic_ostream&lt;charT,traits&gt;&amp; flush();
-
-      // _lib.ostream.seeks_ seeks:
-S     pos_type tellp();
-S     basic_ostream&lt;charT,traits&gt;&amp; seekp(pos_type);
-S     basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type, ios_base::seekdir);
-    };
-    // _lib.ostream.inserters.character_ character inserters
-X   template&lt;class charT, class traits&gt;
-    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
-                                            charT);
-X   template&lt;class charT, class traits&gt;
-    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
-                                            char);
-    // specialization
-X   template&lt;class traits&gt;
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
-                                             char);
-    // signed and unsigned
-X   template&lt;class traits&gt;
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
-                                             signed char);
-X   template&lt;class traits&gt;
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
-                                             unsigned char)
-X   template&lt;class charT, class traits&gt;
-      basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
-                                              const charT*);
-X   template&lt;class charT, class traits&gt;
-      basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
-                                              const char*);
-    // partial specializationss
-X   template&lt;class traits&gt;
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
-                                             const char*);
-    //  signed and unsigned
-X   template&lt;class traits&gt;
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
-                                             const signed char*);
-X   template&lt;class traits&gt;
-      basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
-                                             const unsigned char*);
-
-
-   27.6.2.3  Class basic_ostream::sentry            [lib.ostream::sentry]
-
-    template &lt;class charT,class traits = char_traits&lt;charT&gt; &gt;
-X   class basic_ostream&lt;charT,traits&gt;::sentry {
-      bool ok_; // exposition only
-     public:
-X     explicit sentry(basic_ostream&lt;charT,traits&gt;&amp; os);
-X     ~sentry();
-X     operator bool() const { return ok_; }
-     private
-X     sentry(const sentry&amp;); //   not defined
-X     sentry&amp; operator=(const sentry&amp;); //   not defined
-    };
-
-   27.7  String-based streams                        [lib.string.streams]
-
-   Header &lt;sstream&gt; synopsis
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-                      class Allocator = allocator&lt;charT&gt; &gt;
-      class basic_stringbuf;
-
-T   typedef basic_stringbuf&lt;char&gt;     stringbuf;
-T   typedef basic_stringbuf&lt;wchar_t&gt; wstringbuf;
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-                      class Allocator = allocator&lt;charT&gt; &gt;
-X     class basic_istringstream;
-
-T   typedef basic_istringstream&lt;char&gt;     istringstream;
-T   typedef basic_istringstream&lt;wchar_t&gt; wistringstream;
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-                      class Allocator = allocator&lt;charT&gt; &gt;
-X     class basic_ostringstream;
-T   typedef basic_ostringstream&lt;char&gt;     ostringstream;
-T   typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-                      class Allocator = allocator&lt;charT&gt; &gt;
-X     class basic_stringstream;
-T   typedef basic_stringstream&lt;char&gt;     stringstream;
-T   typedef basic_stringstream&lt;wchar_t&gt; wstringstream;
-
-   27.7.1  Template class basic_stringbuf                 [lib.stringbuf]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-X   class basic_stringbuf : public basic_streambuf&lt;charT,traits&gt; {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.stringbuf.cons_ Constructors:
-S     explicit basic_stringbuf(ios_base::openmode which
-                                = ios_base::in | ios_base::out);
-S     explicit basic_stringbuf
-          (const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
-           ios_base::openmode which = ios_base::in | ios_base::out);
-      // _lib.stringbuf.members_ Get and set:
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;
-S     void               str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);
-
-    protected:
-      // _lib.stringbuf.virtuals_ Overridden virtual functions:
-S     virtual int_type   underflow();
-S     virtual int_type   pbackfail(int_type c = traits::eof());
-S     virtual int_type   overflow (int_type c = traits::eof());
-S     virtual  basic_streambuf&lt;charT,traits&gt;* setbuf(charT*, streamsize);
-
-S     virtual pos_type   seekoff(off_type off, ios_base::seekdir way,
-                                 ios_base::openmode which
-                                  = ios_base::in | ios_base::out);
-S     virtual pos_type   seekpos(pos_type sp,
-                                 ios_base::openmode which
-                                  = ios_base::in | ios_base::out);
-    };
-
-
-   27.7.2  Template class basic_istringstream         [lib.istringstream]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-X   class basic_istringstream : public basic_istream&lt;charT,traits&gt; {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.istringstream.cons_ Constructors:
-S     explicit basic_istringstream(ios_base::openmode which = ios_base::in);
-S     explicit basic_istringstream(
-                         const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
-                         ios_base::openmode which = ios_base::in);
-
-      // _lib.istringstream.members_ Members:
-S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;
-S     void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);
-   private:
-   //  basic_stringbuf&lt;charT,traits,Allocator&gt; sb;   exposition only
-    };
-
-   27.7.3  Class basic_ostringstream                  [lib.ostringstream]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-X   class basic_ostringstream : public basic_ostream&lt;charT,traits&gt; {
-    public:
-
-      // Types:
-T     typedef charT            char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-      // _lib.ostringstream.cons_ Constructors/destructor:
-S     explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
-S     explicit basic_ostringstream(
-                           const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
-                           ios_base::openmode which = ios_base::out);
-      // _lib.ostringstream.members_ Members:
-S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;
-S     void    str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);
-    };
-
-
-   27.7.4  Template class basic_stringstream           [lib.stringstream]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt;,
-              class Allocator = allocator&lt;charT&gt; &gt;
-X   class basic_stringstream
-      : public basic_iostream&lt;charT,traits&gt; {
-    public:
-      // Types
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-      // constructors/destructors
-S     explicit basic_stringstream(
-          ios_base::openmode which = ios_base::out|ios_base::in);
-S     explicit basic_stringstream(
-          const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
-          ios_base::openmode which = ios_base::out|ios_base::in);
-      // Members:
-S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
-S     basic_string&lt;charT,traits,Allocator&gt; str() const;
-S     void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
-    };
-
-
-
-   27.8.1  File streams                                    [lib.fstreams]
-
-
-   Header &lt;fstream&gt; synopsis
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_filebuf;
-T   typedef basic_filebuf&lt;char&gt;    filebuf;
-T   typedef basic_filebuf&lt;wchar_t&gt; wfilebuf;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ifstream;
-T   typedef basic_ifstream&lt;char&gt;    ifstream;
-T   typedef basic_ifstream&lt;wchar_t&gt; wifstream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_ofstream;
-T   typedef basic_ofstream&lt;char&gt;    ofstream;
-T   typedef basic_ofstream&lt;wchar_t&gt; wofstream;
-
-X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-      class basic_fstream;
-T   typedef basic_fstream&lt;char&gt;     fstream;
-T   typedef basic_fstream&lt;wchar_t&gt; wfstream;
-
-   27.8.1.1  Template class basic_filebuf                   [lib.filebuf]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-X   class basic_filebuf : public basic_streambuf&lt;charT,traits&gt; {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.filebuf.cons_ Constructors/destructor:
-X     basic_filebuf();
-X     virtual ~basic_filebuf();
-       // _lib.filebuf.members_ Members:
-T     bool is_open() const;
-X     basic_filebuf&lt;charT,traits&gt;* open
-          (const char* s, ios_base::openmode mode);
-X     basic_filebuf&lt;charT,traits&gt;* close();
-    protected:
-      // _lib.filebuf.virtuals_ Overridden virtual functions:
-X     virtual streamsize showmanyc();
-X     virtual int_type underflow();
-X     virtual int_type uflow();
-X     virtual int_type pbackfail(int_type c = traits::eof());
-X     virtual int_type overflow (int_type c = traits::eof());
-S     virtual basic_streambuf&lt;charT,traits&gt;*
-                       setbuf(char_type* s, streamsize n);
-S     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
-                               ios_base::openmode which
-                                 = ios_base::in | ios_base::out);
-S     virtual pos_type seekpos(pos_type sp, ios_base::openmode which
-                                 = ios_base::in | ios_base::out);
-S     virtual int      sync();
-S     virtual void     imbue(const locale&amp; loc);
-    };
-
-
-
-   27.8.1.5  Template class basic_ifstream                 [lib.ifstream]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-X   class basic_ifstream : public basic_istream&lt;charT,traits&gt; {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.ifstream.cons_ Constructors:
-S     basic_ifstream();
-S     explicit basic_ifstream(const char* s,
-                              ios_base::openmode mode = ios_base::in);
-      // _lib.ifstream.members_ Members:
-S     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
-S     bool is_open();
-S     void open(const char* s, ios_base::openmode mode = ios_base::in);
-S     void close();
-    };
-
-
-   27.8.1.8  Template class basic_ofstream                 [lib.ofstream]
-
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-X   class basic_ofstream : public basic_ostream&lt;charT,traits&gt; {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // _lib.ofstream.cons_ Constructors:
-X     basic_ofstream();
-X     explicit basic_ofstream(const char* s,
-                              ios_base::openmode mode
-                                = ios_base::out);
-      // _lib.ofstream.members_ Members:
-X     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
-T     bool is_open();
-X     void open(const char* s, ios_base::openmode mode = ios_base::out);
-X     void close();
-    };
-
-
-   27.8.1.11  Template class basic_fstream                  [lib.fstream]
-
-    template &lt;class charT, class traits=char_traits&lt;charT&gt; &gt;
-X   class basic_fstream
-      : public basic_iostream&lt;charT,traits&gt; {
-    public:
-T     typedef charT                     char_type;
-T     typedef typename traits::int_type int_type;
-T     typedef typename traits::pos_type pos_type;
-T     typedef typename traits::off_type off_type;
-T     typedef traits                    traits_type;
-      // constructors/destructor
-S     basic_fstream();
-S     explicit basic_fstream(
-          const char* s,
-          ios_base::openmode mode = ios_base::in|ios_base::out);
-
-      // Members:
-S     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
-S     bool is_open();
-S     void open(
-          const char* s,
-          ios_base::openmode mode = ios_base::in|ios_base::out);
-S     void close();
-    };
-
-
-
-   27.8.2  C Library files                                  [lib.c.files]
-
-
-                    Table 13--Header &lt;cstdio&gt; synopsis
-    Macros:
-X   BUFSIZ         L_tmpnam        SEEK_SET   TMP_MAX
-X   EOF            NULL &lt;cstdio&gt;   stderr     _IOFBF
-X   FILENAME_MAX   SEEK_CUR        stdin      _IOLBF
-X   FOPEN_MAX      SEEK_END        stdout     _IONBF
-
-X   Types:         FILE            fpos_t     size_t &lt;cstdio&gt;
-    Functions:
-X   clearerr       fgets           fscanf     gets     rewind
-X   fclose         fopen           fseek      perror   scanf     tmpnam
-X   feof           fprintf         fsetpos    printf   setbuf    ungetc
-X   ferror         fputc           ftell      putc     setvbuf   vprintf
-X   fflush         fputs           fwrite     puts     sprintf   vfprintf
-X   fgetc          fread           getc       remove   sscanf    vsprintf
-X   fgetpos        freopen         getchar    putchar  rename    tmpfile
-
-
-
-
-   1.5  Standard C library headers                       [depr.c.headers]
-
-X     &lt;assert.h&gt;   &lt;iso646.h&gt;   &lt;setjmp.h&gt;   &lt;stdio.h&gt;    &lt;wchar.h&gt;
-      &lt;ctype.h&gt;    &lt;limits.h&gt;   &lt;signal.h&gt;   &lt;stdlib.h&gt;   &lt;wctype.h&gt;
-      &lt;errno.h&gt;    &lt;locale.h&gt;   &lt;stdarg.h&gt;   &lt;string.h&gt;
-      &lt;float.h&gt;    &lt;math.h&gt;     &lt;stddef.h&gt;   &lt;time.h&gt;
-
-   1.6  Old iostreams members                          [depr.ios.members]
-
-   [Note: these should be #ifdef'd to permit diagnostics if used.]
-   namespace std {
-    class ios_base {
-    public:
-T     typedef T1  io_state;
-T     typedef T2 open_mode;
-T     typedef T3  seek_dir;
-T     typedef OFF_T  streamoff;
-T     typedef OFF_T  streampos;
-      // remainder unchanged
-    };
-   }
-
-   [Note: these should be #ifdef'd to permit diagnostics if used.]
-   namespace std {
-    template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-    class basic_streambuf {
-    public:
-T     void stossc();
-      // remainder unchanged
-    };
-   }
-
-   8 An implementation may provide  the  following  member  functions  that
-   overload signatures specified in clause _lib.iostreams_:
-
-   [Note: the following overloads should be #ifdef'd to permit
-    diagnostics to be emitted, by default, if used.]
-
-    template&lt;class charT, class Traits&gt; class basic_ios {
-    public:
-M     void clear(io_state state);
-M     void setstate(io_state state);
-      // remainder unchanged
-    };
-    class ios_base {
-    public:
-M     void exceptions(io_state);
-      // remainder unchanged
-    };
-    template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-    class basic_streambuf {
-    public:
-M     pos_type pubseekoff(off_type off, ios_base::seek_dir way,
-                ios_base::open_mode which = ios_base::in | ios_base::out);
-M     pos_type pubseekpos(pos_type sp,
-                ios_base::open_mode which = ios_base::in | ios_base::out);
-      // remainder unchanged
-    };
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-    class basic_filebuf : public basic_streambuf&lt;charT,traits&gt; {
-    public:
-M     basic_filebuf&lt;charT,traits&gt;* open
-          (const char* s, ios_base::open_mode mode);
-      // remainder unchanged
-    };
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-    class basic_ifstream : public basic_istream&lt;charT,traits&gt; {
-    public:
-M     void open(const char* s, ios_base::open_mode mode = in);
-      // remainder unchanged
-    };
-    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
-    class basic_ofstream : public basic_ostream&lt;charT,traits&gt; {
-    public:
-M     void open(const char* s, ios_base::open_mode mode = out | trunc);
-      // remainder unchanged
-    };
-   }
-
-
-
-   1.7.1  Class strstreambuf                          [depr.strstreambuf]
-
-   [Note: It should be possible to adopt these components with only
-    minor changes from the 2.8 version of the library.]
-
-M   class strstreambuf : public basic_streambuf&lt;char&gt; {
-    public:
-M     explicit strstreambuf(streamsize alsize_arg = 0);
-M     strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
-M     strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
-M     strstreambuf(const char* gnext_arg, streamsize n);
-M     strstreambuf(signed char* gnext_arg, streamsize n,
-                   signed char* pbeg_arg = 0);
-M     strstreambuf(const signed char* gnext_arg, streamsize n);
-M     strstreambuf(unsigned char* gnext_arg, streamsize n,
-                   unsigned char* pbeg_arg = 0);
-M     strstreambuf(const unsigned char* gnext_arg, streamsize n);
-M     virtual ~strstreambuf();
-M     void  freeze(bool freezefl = true);
-M     char* str();
-M     int   pcount();
-    protected:
-M     virtual int_type overflow (int_type c = EOF);
-M     virtual int_type pbackfail(int_type c = EOF);
-M     virtual int_type underflow();
-M     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
-                               ios_base::openmode which
-                                = ios_base::in | ios_base::out);
-M     virtual pos_type seekpos(pos_type sp, ios_base::openmode which
-                                = ios_base::in | ios_base::out);
-M     virtual streambuf&lt;char&gt;* setbuf(char* s, streamsize n);
-   }
-
-   1.7.4  Class strstream                                [depr.strstream]
-
-M   class strstream
-      : public basic_iostream&lt;char&gt; {
-    public:
-      // Types
-M     typedef char                                char_type;
-M     typedef typename char_traits&lt;char&gt;::int_type int_type
-M     typedef typename char_traits&lt;char&gt;::pos_type pos_type;
-M     typedef typename char_traits&lt;char&gt;::off_type off_type;
-      // consturctors/destructor
-M     strstream();
-M     strstream(char* s, int n,
-                ios_base::openmode mode = ios_base::in|ios_base::out);
-M     virtual ~strstream();
-      // Members:
-M     strstreambuf* rdbuf() const;
-M     void freeze(bool freezefl = true);
-M     int pcount() const;
-M     char* str();
-    };
-</literallayout>
-
+<title>C++ 1998/2003</title>
+
+<sect3 id="standard.1998.status" xreflabel="Implementation Status">
+  <title>Implementation Status</title>
+
+<para>
+This status table is based on the table of contents of ISO/IEC 14882:2003.
+</para>
+
+<para>
+This page describes the C++0x support in mainline GCC SVN, not in any
+particular release.
+</para>
+
+<!-- Status is Yes or No, Broken/Partial-->
+<!-- 
+   Yes
+
+   No 
+      <?dbhtml bgcolor="#C8B0B0" ?> 
+   Broken/Partial 
+      <?dbhtml bgcolor="#B0B0B0" ?>  
+-->
+<table frame='all'>
+<title>C++ 1998/2003 Implementation Status</title>
+<tgroup cols='4' align='left' colsep='0' rowsep='1'>
+<colspec colname='c1'></colspec>
+<colspec colname='c2'></colspec>
+<colspec colname='c3'></colspec>
+<colspec colname='c4'></colspec>
+  <thead>
+    <row>
+      <entry>Section</entry>
+      <entry>Description</entry>
+      <entry>Status</entry>
+      <entry>Comments</entry>
+    </row>
+  </thead>
+
+  <tbody>
+    <row>
+      <entry>
+       <emphasis>18</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Language support</emphasis>
+      </entry>
+    </row>
+
+    <row>
+      <entry>18.1</entry>
+      <entry>Types</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.2</entry>
+      <entry>Implementation properties</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.2.1</entry>
+      <entry>Numeric Limits</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.2.1.1</entry>
+      <entry>Class template <code>numeric_limits</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.2.1.2</entry>
+      <entry><code>numeric_limits</code> members</entry>
+      <entry>Y</entry>
+    </row>
+    <row>
+      <entry>18.2.1.3</entry>
+      <entry><code>float_round_style</code></entry>
+      <entry>Y</entry>
+    </row>
+    <row>
+      <entry>18.2.1.4</entry>
+      <entry><code>float_denorm_style</code></entry>
+      <entry>Y</entry>
+    </row>
+    <row>
+      <entry>18.2.1.5</entry>
+      <entry><code>numeric_limits</code> specializations</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.2.2</entry>
+      <entry>C Library</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.3</entry>
+      <entry>Start and termination</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.4</entry>
+      <entry>Dynamic memory management</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.5</entry>
+      <entry>Type identification</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.5.1</entry>
+      <entry>Class type_info</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.5.2</entry>
+      <entry>Class bad_cast</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.5.3</entry>
+      <entry>Class bad_typeid</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.6</entry>
+      <entry>Exception handling</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.6.1</entry>
+      <entry>Class exception</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.6.2</entry>
+      <entry>Violation exception-specifications</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.6.3</entry>
+      <entry>Abnormal termination</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.6.4</entry>
+      <entry><code>uncaught_exception</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>18.7</entry>
+      <entry>Other runtime support</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>19</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Diagnostics</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>19.1</entry>
+      <entry>Exception classes</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>19.2</entry>
+      <entry>Assertions</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>19.3</entry>
+      <entry>Error numbers</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>20</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>General utilities</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>20.1</entry>
+      <entry>Requirements</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+   <row>
+      <entry>20.2</entry>
+      <entry>Utility components</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.2.1</entry>
+      <entry>Operators</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.2.2</entry>
+      <entry><code>pair</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+   <row>
+      <entry>20.3</entry>
+      <entry>Function objects</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.1</entry>
+      <entry>Base</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.2</entry>
+      <entry>Arithmetic operation</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.3</entry>
+      <entry>Comparisons</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.4</entry>
+      <entry>Logical operations</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.5</entry>
+      <entry>Negators</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.6</entry>
+      <entry>Binders</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.7</entry>
+      <entry>Adaptors for pointers to functions</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.3.8</entry>
+      <entry>Adaptors for pointers to members</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4</entry>
+      <entry>Memory</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.1</entry>
+      <entry>The default allocator</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.2</entry>
+      <entry>Raw storage iterator</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.3</entry>
+      <entry>Temporary buffers</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.4</entry>
+      <entry>Specialized algorithms</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.4.1</entry>
+      <entry><code>uninitialized_copy</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.4.2</entry>
+      <entry><code>uninitialized_fill</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.4.3</entry>
+      <entry><code>uninitialized_fill_n</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.5</entry>
+      <entry>Class template <code>auto_ptr</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>20.4.6</entry>
+      <entry>C library</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>21</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Strings</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>21.1</entry>
+      <entry>Character traits</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.1.1</entry>
+      <entry>Character traits requirements</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.1.2</entry>
+      <entry>traits typedef</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.1.3</entry>
+      <entry><code>char_traits</code> specializations</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.1.3.1</entry>
+      <entry>struct <code>char_traits&lt;char&gt;</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.1.3.2</entry>
+      <entry>struct <code>char_traits&lt;wchar_t&gt;</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.2</entry>
+      <entry>String classes</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.3</entry>
+      <entry>Class template <code>basic_string</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>21.4</entry>
+      <entry>Null-terminated sequence utilities</entry>
+      <entry>Y</entry>
+      <entry>C library dependency</entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>22</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Localization</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>22.1</entry>
+      <entry>Locales</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.1.1</entry>
+      <entry>Class <code>locale</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.1.2</entry>
+      <entry><code>locale</code> globals</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.1.3</entry>
+      <entry>Convenience interfaces</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.1.3.1</entry>
+      <entry>Character classification</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.1.3.2</entry>
+      <entry>Character conversions</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2</entry>
+      <entry>Standard locale categories</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.1</entry>
+      <entry><code>ctype</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.2</entry>
+      <entry>Numeric</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.2.1</entry>
+      <entry><code>num_get</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.2.2</entry>
+      <entry><code>num_put</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.3</entry>
+      <entry><code>num_punct</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.4</entry>
+      <entry><code>collate</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.5</entry>
+      <entry>Time</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.5.1</entry>
+      <entry><code>time_get</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.5.2</entry>
+      <entry><code>time_get_byname</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.5.3</entry>
+      <entry><code>time_put</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.5.3</entry>
+      <entry><code>time_put_byname</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.6</entry>
+      <entry>Monetary</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.6.1</entry>
+      <entry><code>money_get</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.6.2</entry>
+      <entry><code>money_put</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.6.3</entry>
+      <entry><code>money_punct</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.6.4</entry>
+      <entry><code>money_punct_byname</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.7</entry>
+      <entry><code>messages</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.2.8</entry>
+      <entry>Program-defined facets</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>22.3</entry>
+      <entry>C Library Locales</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>23</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Containers</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>23.1</entry>
+      <entry>Container requirements</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2</entry>
+      <entry>Sequence containers</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.1</entry>
+      <entry>Class template <code>deque</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.2</entry>
+      <entry>Class template <code>list</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.3</entry>
+      <entry>Adaptors</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.3.1</entry>
+      <entry>Class template <code>queue</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.3.2</entry>
+      <entry>Class template <code>priority_queue</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.3.3</entry>
+      <entry>Class template <code>stack</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.4</entry>
+      <entry>Class template <code>vector</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.2.5</entry>
+      <entry>Class <code>vector&lt;bool&gt;</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.3</entry>
+      <entry>Associative containers</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.3.1</entry>
+      <entry>Class template <code>map</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.3.2</entry>
+      <entry>Class template <code>multimap</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.3.3</entry>
+      <entry>Class template <code>set</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>23.3.4</entry>
+      <entry>Class template <code>multiset</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>24</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Iterators</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>24.1</entry>
+      <entry>Requirements</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.2</entry>
+      <entry>Header <code>&lt;iterator&gt;</code> synopsis</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.3</entry>
+      <entry>Iterator primitives</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.4</entry>
+      <entry>Predefined iterators and Iterator adaptors</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.4.1</entry>
+      <entry>Reverse iterators</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.4.2</entry>
+      <entry>Insert iterators</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.5</entry>
+      <entry>Stream iterators</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.5.1</entry>
+      <entry>Class template <code>istream_iterator</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.5.2</entry>
+      <entry>Class template <code>ostream_iterator</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.5.3</entry>
+      <entry>Class template <code>istreambuf_iterator</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>24.5.4</entry>
+      <entry>Class template <code>ostreambuf_iterator</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>25</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Algorithms</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>25.1</entry>
+      <entry>Non-modifying sequence operations</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>25.2</entry>
+      <entry>Mutating sequence operations</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>25.3</entry>
+      <entry>Sorting and related operations</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>25.4</entry>
+      <entry>C library algorithms</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+      <emphasis>26</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Numerics</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>26.1</entry>
+      <entry>Numeric type requirements</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.2</entry>
+      <entry>Complex numbers</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3</entry>
+      <entry>Numeric arrays</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.1</entry>
+      <entry>Header <code>&lt;valarray&gt;</code> synopsis</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.2</entry>
+      <entry>Class template <code>valarray</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.3</entry>
+      <entry><code>valarray</code> non-member operations</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.4</entry>
+      <entry>Class <code>slice</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.5</entry>
+      <entry>Class template <code>slice_array</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.6</entry>
+      <entry>Class <code>gslice</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.7</entry>
+      <entry>Class template <code>gslice_array</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.8</entry>
+      <entry>Class template <code>mask_array</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.3.9</entry>
+      <entry>Class template <code>indirect_array</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.4</entry>
+      <entry>Generalized numeric operations</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.4.1</entry>
+      <entry><code>accumulate</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.4.2</entry>
+      <entry><code>inner_product</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.4.3</entry>
+      <entry><code>partial_sum</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.4.4</entry>
+      <entry><code>adjacent_difference</code></entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.4.5</entry>
+      <entry>iota</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>26.5</entry>
+      <entry>C Library</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>27</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Input/output</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>27.1</entry>
+      <entry>Requirements</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.2</entry>
+      <entry>Forward declarations</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.3</entry>
+      <entry>Standard iostream objects</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.3.1</entry>
+      <entry>Narrow stream objects</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.3.2</entry>
+      <entry>Wide stream objects</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.4</entry>
+      <entry>Iostreams base classes</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.5</entry>
+      <entry>Stream buffers</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.6</entry>
+      <entry>Formatting and manipulators</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.7</entry>
+      <entry>String-based streams</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>27.8</entry>
+      <entry>File-based streams</entry>
+      <entry>Y</entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>
+       <emphasis>Appendix D</emphasis>
+      </entry>
+      <entry namest="c2" nameend="c4" align="left">
+       <emphasis>Compatibility features</emphasis>
+      </entry>
+    </row>
+    <row>
+      <entry>D.1</entry>
+      <entry>Increment operator with bool operand</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>D.2</entry>
+      <entry><code>static</code> keyword</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>D.3</entry>
+      <entry>Access declarations</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>D.4</entry>
+      <entry>Implicit conversion from const strings</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>D.5</entry>
+      <entry>C standard library headers</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>D.6</entry>
+      <entry>Old iostreams members</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+    <row>
+      <entry>D.7</entry>
+      <entry>char* streams</entry>
+      <entry></entry>
+      <entry></entry>
+    </row>
+
+  </tbody>
+</tgroup>
+</table>
 </sect3>
 
-
 <sect3 id="standard.1998.specific" xreflabel="Implementation Specific">
   <title>Implementation Specific Behavior</title>
 
index 3946165..2ff0e62 100644 (file)
@@ -1,5 +1,5 @@
 <sect2 id="manual.intro.status.standard.200x" xreflabel="Status C++ 200x">
-<?dbhtml filename="standard_cxx200x.html"?>
+<?dbhtml filename="status_iso_cxx200x.html"?>
  
 <sect2info>
   <keywordset>
index 508d443..33172e3 100644 (file)
@@ -1,5 +1,5 @@
 <sect2 id="manual.intro.status.standard.tr1" xreflabel="Status C++ TR1">
-<?dbhtml filename="standard_cxxtr1.html"?>
+<?dbhtml filename="status_iso_cxxtr1.html"?>
  
 <sect2info>
   <keywordset>
index 5e81fbc..6e0f75a 100644 (file)
@@ -38,6 +38,7 @@
 </preface>
 
 <chapter id="manual.support.types" xreflabel="Types">
+  <?dbhtml filename="fundamental_types.html"?>
   <title>Types</title>
   <sect1 id="manual.support.types.fundamental" xreflabel="Fundamental Types">
     <title>Fundamental Types</title>
 </chapter>
 
 <chapter id="manual.support.memory" xreflabel="Dynamic Memory">
+  <?dbhtml filename="dynamic_memory.html"?>
   <title>Dynamic Memory</title>
   <para>
     There are six flavors each of <function>new</function> and
 </chapter>
 
 <chapter id="manual.support.termination" xreflabel="Termination">
+  <?dbhtml filename="termination.html"?>
   <title>Termination</title>
   <sect1 id="support.termination.handlers" xreflabel="Termination Handlers">
     <title>Termination Handlers</title>
   </sect1>
 
   <sect1 id="support.termination.verbose" xreflabel="Verbose Terminate Handler">
+  <?dbhtml filename="verbose_termination.html"?>
     <title>Verbose Terminate Handler</title>
     <para>
       If you are having difficulty with uncaught exceptions and want a
index d1a8914..7b75b8b 100644 (file)
@@ -4,7 +4,7 @@
 [ ]>
 
 <chapter id="manual.intro.using" xreflabel="Using">
-<?dbhtml filename="using.html"?>
+  <?dbhtml filename="using.html"?>
 
 <title>Using</title>
 
@@ -78,6 +78,7 @@
   </sect1>
 
   <sect1 id="manual.intro.using.headers" xreflabel="Headers">
+    <?dbhtml filename="using_headers.html"?>
     <title>Headers</title>
 
     <sect2 id="manual.intro.using.headers.all" xreflabel="Header Files">
@@ -706,6 +707,7 @@ g++ -Winvalid-pch -I. -include stdc++.h -H -g -O2 hello.cc -o test.exe
   </sect1>
 
   <sect1 id="manual.intro.using.namespaces" xreflabel="Namespaces">
+    <?dbhtml filename="using_namespaces.html"?>
     <title>Namespaces</title>
 
     <sect2 id="manual.intro.using.namespaces.all" xreflabel="Available Namespaces">
@@ -817,6 +819,7 @@ namespace gtk
   </sect1>
 
   <sect1 id="manual.intro.using.macros" xreflabel="Macros">
+    <?dbhtml filename="using_macros.html"?>
     <title>Macros</title>
 
    <para>All pre-processor switches and configurations are all gathered
@@ -943,6 +946,7 @@ namespace gtk
   </sect1>  
   
   <sect1 id="manual.intro.using.concurrency" xreflabel="Concurrency">
+    <?dbhtml filename="using_concurrency.html"?>
     <title>Concurrency</title>
 
    <para>This section discusses issues surrounding the proper compilation
@@ -1261,6 +1265,7 @@ gcc version 4.1.2 20070925 (Red Hat 4.1.2-33)
   </sect1>
 
   <sect1 id="manual.intro.using.exception" xreflabel="Exceptions">
+    <?dbhtml filename="using_exceptions.html"?>
     <title>Exceptions</title>
 
   <sect2 id="intro.using.exception.propagating" xreflabel="Propagating Exceptions">
index a2de43d..56d614e 100644 (file)
@@ -24,6 +24,7 @@
 
 <!-- Chapter 01 : Functors -->
 <chapter id="manual.util.functors" xreflabel="Functors">
+<?dbhtml filename="functors.html"?>
   <title>Functors</title>
    <para>If you don't know what functors are, you're not alone.  Many people
       get slightly the wrong idea.  In the interest of not reinventing
@@ -36,6 +37,7 @@
 
 <!-- Chapter 02 : Pairs -->
 <chapter id="manual.util.pairs" xreflabel="Pairs">
+<?dbhtml filename="pairs.html"?>
   <title>Pairs</title>
    <para>The <code>pair&lt;T1,T2&gt;</code> is a simple and handy way to
       carry around a pair of objects.  One is of type T1, and another of
@@ -91,7 +93,7 @@
 
 <!-- Chapter 03 : Memory -->
 <chapter id="manual.util.memory" xreflabel="Memory">
-
+<?dbhtml filename="memory.html"?>
   <title>Memory</title>
   <para>
     Memory contains three general areas. First, function and operator
 
 <!-- Chapter 04 : Traits -->
 <chapter id="manual.util.traits" xreflabel="Traits">
+<?dbhtml filename="traits.html"?>
   <title>Traits</title>
   <para>
   </para>