
   Completion Checklist for the Standard C++ Library
   Updated: 1999-05-18

   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:  (restricted site)
     http://www.cygnus.com/iso/wp/html/fdis/lwg-issues.html
   The LWG has announced its intention to release a public version
   of the issues list, URL to be added here.   XXX

   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.

   ----------------------------------------------------------------------
       <algorithm>    <iomanip>    <list>      <ostream>     <streambuf>
       <bitset>       <ios>        <locale>    <queue>       <string>
       <complex>      <iosfwd>     <map>       <set>         <typeinfo>
X      <deque>        <iostream>   <memory>    <sstream>     <utility>
       <exception>    <istream>    <new>       <stack>       <valarray>
       <fstream>      <iterator>   <numeric>   <stdexcept>   <vector>
       <functional>   <limits>

   [C header names must be in std:: to qualify.  Related to shadow/ dir.]
           <cassert> <ciso646> <csetjmp> <cstdio>  <ctime>
           <cctype>  <climits> <csignal> <cstdlib> <cwchar>
X          <cerrno>  <clocale> <cstdarg> <cstring> <cwctype>
           <cfloat>  <cmath>   <cstddef>

    Macro:
X   errno,  declared  or  defined in <cerrno>.

    Macro fn:
X   setjmp(jmp_buf), declared or defined in <csetjmp>
X   va_end(va_list), declared or defined in <cstdarg>

    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	<cstddef>
X	NULL
X  	offsetof
X	ptrdiff_t
X	size_t

   18.2  Implementation properties                   [lib.support.limits]

    <limits>, <climits>, and <cfloat>

   18.2.1  Numeric limits                                    [lib.limits]

   [Note: the numeric_limits templates are now automatically
    generated. ]

X   template<class T> class numeric_limits;

T   enum float_round_style;
T   enum float_denorm_style;

T   template<> class numeric_limits<bool>;

T   template<> class numeric_limits<char>;
T   template<> class numeric_limits<signed char>;
T   template<> class numeric_limits<unsigned char>;
T   template<> class numeric_limits<wchar_t>;

T   template<> class numeric_limits<short>;
T   template<> class numeric_limits<int>;
T   template<> class numeric_limits<long>;
T   template<> class numeric_limits<unsigned short>;
T   template<> class numeric_limits<unsigned int>;
T   template<> class numeric_limits<unsigned long>;

X   template<> class numeric_limits<float>;
X   template<> class numeric_limits<double>;
X   template<> class numeric_limits<long double>;

   18.2.1.1  Template class numeric_limits           [lib.numeric.limits]
T   template<class T> 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 <climits> (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 <cfloat> (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 <cstdlib> (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 <new> 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&) throw();
T    void  operator delete(void* ptr) throw();
T    void  operator delete(void* ptr, const std::nothrow_t&) 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&) throw();
T    void  operator delete[](void* ptr) throw();
T    void  operator delete[](void* ptr, const std::nothrow_t&) 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&) throw();
T     bad_alloc& operator=(const bad_alloc&) 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 <typeinfo> 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& rhs) const;
T      bool operator!=(const type_info& rhs) const;
T      bool before(const type_info& rhs) const;
T      const char* name() const;
    private:
T      type_info(const type_info& rhs);
T      type_info& operator=(const type_info& 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&) throw();
T      bad_typeid& operator=(const bad_typeid&) throw();
T      virtual ~bad_typeid() throw();
T      virtual const char* what() const throw();
    };

   18.6  Exception handling                       [lib.support.exception]

T      Header <exception> 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&) throw();
T      exception& operator=(const exception&) 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&) throw();
T      bad_exception& operator=(const bad_exception&) throw();
T      virtual ~bad_exception() throw();
T      virtual const char* what() const throw();
    };

   18.7  Other runtime support                      [lib.support.runtime]

   1 Headers <cstdarg> (variable arguments),  <csetjmp>  (nonlocal  jumps),
    <ctime>  (system  clock clock(), time()), <csignal> (signal handling),
    and <cstdlib> (runtime environment getenv(), system()).

                    Table 6--Header <cstdarg> synopsis
                 Macros:   va_arg    va_end   va_start
X                Type:     va_list

                    Table 7--Header <csetjmp> synopsis

                          Macro:      setjmp |
X                         Type:       jmp_buf
                          Function:   longjmp

                     Table 8--Header <ctime> synopsis

                      Macros:      CLOCKS_PER_SEC
X                     Types:       clock_t
                      Functions:   clock

                    Table 9--Header <csignal> 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 <cstdlib> synopsis

X                     Functions:   getenv   system

   19.1  Exception classes                           [lib.std.exceptions]

   Header <stdexcept> 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& 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& 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& 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& 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& what_arg);
    };


   19.1.6  Class runtime_error                        [lib.runtime.error]

T   class runtime_error : public exception {
    public:
T     explicit runtime_error(const string& 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& 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& 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& what_arg);
    };


   19.2  Assertions                                      [lib.assertions]

                    Table 2--Header <cassert> synopsis

X                         Macro:   assert

   19.3  Error numbers                                        [lib.errno]

                    Table 3--Header <cerrno> synopsis

X                    |Macros:   EDOM   ERANGE   errno |


   20.2  Utility components                                 [lib.utility]

   Header <utility> synopsis

    // _lib.operators_, operators:
X    namespace rel_ops {
T      template<class T> bool operator!=(const T&, const T&);
T      template<class T> bool operator> (const T&, const T&);
T      template<class T> bool operator<=(const T&, const T&);
T      template<class T> bool operator>=(const T&, const T&);
    }
    // _lib.pairs_, pairs:
T   template <class T1, class T2> struct pair;
T   template <class T1, class T2>
      bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2>
      bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
T   template <class T1, class T2> pair<T1,T2> make_pair(const T1&, const T2&);


   20.2.2  Pairs                                              [lib.pairs]

T  template <class T1, class T2>
   struct pair {
T    typedef T1 first_type;
T    typedef T2 second_type;

T    T1 first;
T    T2 second;
T    pair();
T    pair(const T1& x, const T2& y);
T    template<class U, class V> pair(const pair<U, V> &p);
   };

   20.3  Function objects                          [lib.function.objects]

   Header <functional> synopsis

    // _lib.base_, base:
V   template <class Arg, class Result> struct unary_function;
V   template <class Arg1, class Arg2, class Result> struct binary_function;

    // _lib.arithmetic.operations_, arithmetic operations:
V   template <class T> struct plus;
V   template <class T> struct minus;
V   template <class T> struct multiplies;
V   template <class T> struct divides;
V   template <class T> struct modulus;
V   template <class T> struct negate;
    // _lib.comparisons_, comparisons:
V   template <class T> struct equal_to;
V   template <class T> struct not_equal_to;
V   template <class T> struct greater;
V   template <class T> struct less;
V   template <class T> struct greater_equal;
V   template <class T> struct less_equal;
    // _lib.logical.operations_, logical operations:
V   template <class T> struct logical_and;
V   template <class T> struct logical_or;
V   template <class T> struct logical_not;
    // _lib.negators_, negators:
    template <class Predicate> struct unary_negate;
V   template <class Predicate>
      unary_negate<Predicate>  not1(const Predicate&);
V   template <class Predicate> struct binary_negate;
V   template <class Predicate>
      binary_negate<Predicate> not2(const Predicate&);
    // _lib.binders_, binders:
V   template <class Operation>  class binder1st;
V   template <class Operation, class T>
      binder1st<Operation> bind1st(const Operation&, const T&);
V   template <class Operation> class binder2nd;
V   template <class Operation, class T>
      binder2nd<Operation> bind2nd(const Operation&, const T&);
    // _lib.function.pointer.adaptors_, adaptors:
V   template <class Arg, class Result> class pointer_to_unary_function;
V   template <class Arg, class Result>
      pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));
V   template <class Arg1, class Arg2, class Result>
      class pointer_to_binary_function;
V   template <class Arg1, class Arg2, class Result>
      pointer_to_binary_function<Arg1,Arg2,Result>
        ptr_fun(Result (*)(Arg1,Arg2));

    // _lib.member.pointer.adaptors_, adaptors:
V   template<class S, class T> class mem_fun_t;
V   template<class S, class T, class A> class mem_fun1_t;
V   template<class S, class T>
        mem_fun_t<S,T> mem_fun(S (T::*f)());
V   template<class S, class T, class A>
        mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
V   template<class S, class T> class mem_fun_ref_t;
V   template<class S, class T, class A> class mem_fun1_ref_t;
V   template<class S, class T>
        mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
V   template<class S, class T, class A>
        mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));

V   template <class S, class T> class const_mem_fun_t;
V   template <class S, class T, class A> class const_mem_fun1_t;
V   template <class S, class T>
      const_mem_fun_t<S,T> mem_fun(S (T::*f)() const);
V   template <class S, class T, class A>
      const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
V   template <class S, class T> class const_mem_fun_ref_t;
V   template <class S, class T, class A> class const_mem_fun1_ref_t;
V   template <class S, class T>
      const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const);
V   template <class S, class T, class A>
      const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
   }

   20.3.1  Base                                                [lib.base]

V   template <class Arg, class Result>
    struct unary_function {
V     typedef Arg    argument_type;
V     typedef Result result_type;
    };
V   template <class Arg1, class Arg2, class Result>
    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 <class T> struct plus : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct minus : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct multiplies : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct divides : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct modulus : binary_function<T,T,T> {
V   T operator()(const T& x, const T& y) const;
   };

T  template <class T> struct negate : unary_function<T,T> {
V   T operator()(const T& x) const;
   };

   20.3.3  Comparisons                                  [lib.comparisons]

T  template <class T> struct equal_to : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct not_equal_to : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct greater : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct less : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct greater_equal : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct less_equal : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

   20.3.4  Logical operations                    [lib.logical.operations]

T  template <class T> struct logical_and : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct logical_or : binary_function<T,T,bool> {
V   bool operator()(const T& x, const T& y) const;
   };

T  template <class T> struct logical_not : unary_function<T,bool> {
V   bool operator()(const T& x) const;
   };

   20.3.5  Negators                                        [lib.negators]

T  template <class Predicate>
    class unary_negate
      : public unary_function<typename Predicate::argument_type,bool> {
   public:
T   explicit unary_negate(const Predicate& pred);
V   bool operator()(const typename Predicate::argument_type& x) const;
   };

T  template <class Predicate>
    class binary_negate
      : public binary_function<typename Predicate::first_argument_type,
          typename Predicate::second_argument_type, bool> {
    public:
T     explicit binary_negate(const Predicate& pred);
V     bool operator()(const typename Predicate::first_argument_type&  x,
          const typename Predicate::second_argument_type& y) const;
    };


   20.3.6  Binders                                          [lib.binders]

   20.3.6.1  Template class binder1st                    [lib.binder.1st]
T   template <class Operation>
    class binder1st
      : public unary_function<typename Operation::second_argument_type,
                              typename Operation::result_type> {
    protected:
T     Operation                      op;
T     typename Operation::first_argument_type value;
    public:
V     binder1st(const Operation& x,
                const typename Operation::first_argument_type& y);
V     typename Operation::result_type
        operator()(const typename Operation::second_argument_type& x) const;
    };

   20.3.6.2  bind1st                                       [lib.bind.1st]

V  template <class Operation, class T>
    binder1st<Operation> bind1st(const Operation& op, const T& x);

   20.3.6.3  Template class binder2nd                    [lib.binder.2nd]
T   template <class Operation>
    class binder2nd
      : public unary_function<typename Operation::first_argument_type,
                              typename Operation::result_type> {
    protected:
T     Operation                       op;
T     typename Operation::second_argument_type value;
    public:
V     binder2nd(const Operation& x,
                const typename Operation::second_argument_type& y);
V     typename Operation::result_type
        operator()(const typename Operation::first_argument_type& x) const;
    };

   20.3.6.4  bind2nd                                       [lib.bind.2nd]

T  template <class Operation, class T>
    binder2nd<Operation> bind2nd(const Operation& op, const T& 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 <class Arg, class Result>
    class pointer_to_unary_function : public unary_function<Arg, Result> {
    public:
T     explicit pointer_to_unary_function(Result (*f)(Arg));
V     Result operator()(Arg x) const;
    };

T  template <class Arg, class Result>
    pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg));

T       template <class Arg1, class Arg2, class Result>
        class pointer_to_binary_function :
          public binary_function<Arg1,Arg2,Result> {
        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 <class S, class T> class mem_fun_t
          : public unary_function<T*, S> {
   public:
T   explicit mem_fun_t(S (T::*p)());
V   S operator()(T* p) const;
   };

T   template <class S, class T, class A> class mem_fun1_t
          : public binary_function<T*, A, S> {
    public:
T     explicit mem_fun1_t(S (T::*p)(A));
V     S operator()(T* p, A x) const;
   };

V   template<class S, class T> mem_fun_t<S,T>
       mem_fun(S (T::*f)());
V   template<class S, class T, class A> mem_fun1_t<S,T,A>
       mem_fun(S (T::*f)(A));

T   template <class S, class T> class mem_fun_ref_t
          : public unary_function<T, S> {
    public:
T     explicit mem_fun_ref_t(S (T::*p)());
V     S operator()(T& p) const;
   };

T   template <class S, class T, class A> class mem_fun1_ref_t
          : public binary_function<T, A, S> {
    public:
T     explicit mem_fun1_ref_t(S (T::*p)(A));
V     S operator()(T& p, A x) const;
   };

T   template<class S, class T> mem_fun_ref_t<S,T>
       mem_fun_ref(S (T::*f)());

T   template<class S, class T, class A> mem_fun1_ref_t<S,T,A>
       mem_fun_ref(S (T::*f)(A));

T  template <class S, class T> class const_mem_fun_t
        : public unary_function<T*, S> {
   public:
T   explicit const_mem_fun_t(S (T::*p)() const);
V   S operator()(const T* p) const;
   };

T  template <class S, class T, class A> class const_mem_fun1_t
        : public binary_function<T*, A, S> {
   public:
T   explicit const mem_fun1_t(S (T::*p)(A) const);
V   S operator()(const T* p, A x) const;
   };

V   template<class S, class T> const_mem_fun_t<S,T>
       mem_fun(S (T::*f)() const);
V   template<class S, class T, class A> const_mem_fun1_t<S,T,A>
       mem_fun(S (T::*f)(A) const);

T   template <class S, class T> class const_mem_fun_ref_t
          : public unary_function<T, S> {
    public:
T     explicit const_mem_fun_ref_t(S (T::*p)() const);
V     S operator()(const T& p) const;
   };

T   template <class S, class T, class A> class const_mem_fun1_ref_t
          : public binary_function<T, A, S> {
    public:
T     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
V     S operator()(const T& p, A x) const;
   };

T   template<class S, class T> const_mem_fun_ref_t<S,T>
       mem_fun_ref(S (T::*f)() const);

T   template<class S, class T, class A> const_mem_fun1_ref_t<S,T,A>
        mem_fun_ref(S (T::*f)(A) const);

   20.4  Memory                                              [lib.memory]

   Header <memory> synopsis

    // _lib.default.allocator_, the default allocator:
T   template <class T> class allocator;
T   template <> class allocator<void>;
T   template <class T, class U>
      bool operator==(const allocator<T>&, const allocator<U>&) throw();
T   template <class T, class U>
      bool operator!=(const allocator<T>&, const allocator<U>&) throw();
    // _lib.storage.iterator_, raw storage iterator:
T   template <class OutputIterator, class T> class raw_storage_iterator;
    // _lib.temporary.buffer_, temporary buffers:
T   template <class T>
      pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n);
T   template <class T>
      void return_temporary_buffer(T* p);
    // _lib.specialized.algorithms_, specialized algorithms:
T   template <class InputIterator, class ForwardIterator>
      ForwardIterator
        uninitialized_copy(InputIterator first, InputIterator last,
                           ForwardIterator result);
T   template <class ForwardIterator, class T>
      void uninitialized_fill(ForwardIterator first, ForwardIterator last,
                              const T& x);
T   template <class ForwardIterator, class Size, class T>
      void uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
    // _lib.auto.ptr_, pointers:
X   template<class X> class auto_ptr;
   }

   20.4.1  The default allocator                  [lib.default.allocator]

T   template <class T> class allocator;
    // specialize for void:
T   template <> class allocator<void> {
    public:
T     typedef void*       pointer;
T     typedef const void* const_pointer;
      // reference-to-void members are impossible.
T     typedef void  value_type;
T     template <class U> struct rebind { typedef allocator<U> other; };
    };

T   template <class T> 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&        reference;
T     typedef const T&  const_reference;
T     typedef T         value_type;
T     template <class U> struct rebind { typedef allocator<U> other; };
T     allocator() throw();
T     allocator(const allocator&) throw();
T     template <class U> allocator(const allocator<U>&) throw();
T    ~allocator() throw();
T     pointer address(reference x) const;
T     const_pointer address(const_reference x) const;
T     pointer allocate(
        size_type, allocator<void>::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& val);
T     void destroy(pointer p);
    };

   20.4.1.2  allocator globals                    [lib.allocator.globals]

T  template <class T1, class T2>
    bool operator==(const allocator<T1>&, const allocator<T2>&) throw();
T  template <class T1, class T2>
    bool operator!=(const allocator<T1>&, const allocator<T2>&) throw();

   20.4.2  Raw storage iterator                    [lib.storage.iterator]

T   template <class OutputIterator, class T>
    class raw_storage_iterator
      : public iterator<output_iterator_tag,void,void,void,void> {
    public:
T     explicit raw_storage_iterator(OutputIterator x);
T     raw_storage_iterator<OutputIterator,T>& operator*();
T     raw_storage_iterator<OutputIterator,T>& operator=(const T& element);
T     raw_storage_iterator<OutputIterator,T>& operator++();
T     raw_storage_iterator<OutputIterator,T>  operator++(int);
    };

   20.4.3  Temporary buffers                       [lib.temporary.buffer]

T  template <class T>
    pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n);

T  template <class T> 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 <class InputIterator, class ForwardIterator>
    ForwardIterator
      uninitialized_copy(InputIterator first, InputIterator last,
                         ForwardIterator result);

   20.4.4.2  uninitialized_fill                  [lib.uninitialized.fill]

V  template <class ForwardIterator, class T>
    void uninitialized_fill(ForwardIterator first, ForwardIterator last,
                            const T& x);

   20.4.4.3  uninitialized_fill_n              [lib.uninitialized.fill.n]

V  template <class ForwardIterator, class Size, class T>
    void uninitialized_fill_n(ForwardIterator first, Size n, const T& x);

   20.4.5  Template class auto_ptr                         [lib.auto.ptr]

X   template<class X> class auto_ptr {
      template <class Y> 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&) throw();
T     template<class Y> auto_ptr(auto_ptr<Y>&) throw();
T     auto_ptr& operator=(auto_ptr&) throw();
T     template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
T    ~auto_ptr() throw();
      // _lib.auto.ptr.members_ members:
T     X& operator*() const throw();
T     X* operator->() 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<X>) throw();
X     template<class Y> operator auto_ptr_ref<Y>() throw();
X     template<class Y> operator auto_ptr<Y>() throw();
    };

   20.4.6  C Library                                       [lib.c.malloc]

                    Table 7--Header <cstdlib> synopsis

X                    Functions:   calloc   malloc
                                  free     realloc


                    Table 8--Header <cstring> synopsis

X                    Macro:       NULL
X                    Type:        size_t
X                    Functions:   memchr    memcmp
X                    memcpy       memmove   memset

                     Table 9--Header <ctime> 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<class charT> struct char_traits;
   shall be provided in the header <string> as a basis for  explicit spe-
   cializations.


   21.1.3.1  struct                [lib.char.traits.specializations.char]
       char_traits<char>

T   template<>
    struct char_traits<char> {
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& c1, const char_type& c2);
T     static bool eq(const char_type& c1, const char_type& c2);
T     static bool lt(const char_type& c1, const char_type& 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& 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& c);
T     static char_type to_char_type(const int_type& c);
T     static int_type to_int_type(const char_type& c);
T     static bool eq_int_type(const int_type& c1, const int_type& c2);
T     static int_type eof();
    };

   21.1.3.2  struct             [lib.char.traits.specializations.wchar.t]
       char_traits<wchar_t>

V   template<>
    struct char_traits<wchar_t> {
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& c1, const char_type& c2);
V     static bool eq(const char_type& c1, const char_type& c2);
V     static bool lt(const char_type& c1, const char_type& 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& 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& c);
V     static char_type to_char_type(const int_type& c);
V     static int_type to_int_type(const char_type& c);
V     static bool eq_int_type(const int_type& c1, const int_type& c2);
V     static int_type eof();
    };

   21.2  String classes                              [lib.string.classes]

    // _lib.char.traits_, character traits:
V   template<class charT>
      struct char_traits;
V   template <> struct char_traits<char>;
V   template <> struct char_traits<wchar_t>;

    // _lib.basic.string_, basic_string:
V   template<class charT, class traits = char_traits<charT>,
             class Allocator = allocator<charT> >
      class basic_string;
V   template<class charT, class traits, class Allocator>
      basic_string<charT,traits,Allocator>
        operator+(const basic_string<charT,traits,Allocator>& lhs,
                  const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      basic_string<charT,traits,Allocator>
        operator+(const charT* lhs,
                  const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      basic_string<charT,traits,Allocator>
        operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      basic_string<charT,traits,Allocator>
        operator+(const basic_string<charT,traits,Allocator>& lhs,
                  const charT* rhs);
V   template<class charT, class traits, class Allocator>
      basic_string<charT,traits,Allocator>
        operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs);

V   template<class charT, class traits, class Allocator>
      bool operator==(const basic_string<charT,traits,Allocator>& lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator==(const charT* lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator==(const basic_string<charT,traits,Allocator>& lhs,
                      const charT* rhs);
V   template<class charT, class traits, class Allocator>
      bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator!=(const charT* lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
                      const charT* rhs);
V   template<class charT, class traits, class Allocator>
      bool operator< (const basic_string<charT,traits,Allocator>& lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator< (const basic_string<charT,traits,Allocator>& lhs,
                      const charT* rhs);
V   template<class charT, class traits, class Allocator>
      bool operator< (const charT* lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator> (const basic_string<charT,traits,Allocator>& lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator> (const basic_string<charT,traits,Allocator>& lhs,
                      const charT* rhs);
V   template<class charT, class traits, class Allocator>
      bool operator> (const charT* lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
                      const charT* rhs);
V   template<class charT, class traits, class Allocator>
      bool operator<=(const charT* lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
                      const basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
      bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
                      const charT* rhs);
V   template<class charT, class traits, class Allocator>
      bool operator>=(const charT* lhs,
                      const basic_string<charT,traits,Allocator>& rhs);

    // _lib.string.special_:
V   template<class charT, class traits, class Allocator>
       void swap(basic_string<charT,traits,Allocator>& lhs,
                 basic_string<charT,traits,Allocator>& rhs);
V   template<class charT, class traits, class Allocator>
     basic_istream<charT,traits>&
      operator>>(basic_istream<charT,traits>& is,
                 basic_string<charT,traits,Allocator>& str);
T   template<class charT, class traits, class Allocator>
     basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>& os,
                 const basic_string<charT,traits,Allocator>& str);
V   template<class charT, class traits, class Allocator>
     basic_istream<charT,traits>&
       getline(basic_istream<charT,traits>& is,
               basic_string<charT,traits,Allocator>& str,
               charT delim);
V   template<class charT, class traits, class Allocator>
     basic_istream<charT,traits>&
       getline(basic_istream<charT,traits>& is,
               basic_string<charT,traits,Allocator>& str);
V   typedef basic_string<char> string;
T   typedef basic_string<wchar_t> wstring;
   }

   21.3  Template class basic_string                   [lib.basic.string]

V  namespace std {
    template<class charT, class traits = char_traits<charT>,
             class Allocator = allocator<charT> >
    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<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      static const size_type npos = -1;

      // _lib.string.cons_ construct/copy/destroy:
V     explicit basic_string(const Allocator& a = Allocator());
V     basic_string(const basic_string& str, size_type pos = 0,
                   size_type n = npos, const Allocator& a = Allocator());
V     basic_string(const charT* s,
                   size_type n, const Allocator& a = Allocator());
V     basic_string(const charT* s, const Allocator& a = Allocator());
V     basic_string(size_type n, charT c, const Allocator& a = Allocator());
V     template<class InputIterator>
        basic_string(InputIterator begin, InputIterator end,
                     const Allocator& a = Allocator());
V    ~basic_string();
V     basic_string& operator=(const basic_string& str);
V     basic_string& operator=(const charT* s);
V     basic_string& 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& operator+=(const basic_string& str);
V     basic_string& operator+=(const charT* s);
V     basic_string& operator+=(charT c);
V     basic_string& append(const basic_string& str);
V     basic_string& append(const basic_string& str, size_type pos,
                           size_type n);
V     basic_string& append(const charT* s, size_type n);
V     basic_string& append(const charT* s);
V     basic_string& append(size_type n, charT c);
V     template<class InputIterator>
        basic_string& append(InputIterator first, InputIterator last);
V     void push_back(const charT);

V     basic_string& assign(const basic_string&);
V     basic_string& assign(const basic_string& str, size_type pos,
                           size_type n);
V     basic_string& assign(const charT* s, size_type n);
V     basic_string& assign(const charT* s);
V     basic_string& assign(size_type n, charT c);
V     template<class InputIterator>
        basic_string& assign(InputIterator first, InputIterator last);
V     basic_string& insert(size_type pos1, const basic_string& str);
V     basic_string& insert(size_type pos1, const basic_string& str,
                           size_type pos2, size_type n);
V     basic_string& insert(size_type pos, const charT* s, size_type n);
V     basic_string& insert(size_type pos, const charT* s);
V     basic_string& 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<class InputIterator>
        void insert(iterator p, InputIterator first, InputIterator last);
V     basic_string& erase(size_type pos = 0, size_type n = npos);
V     iterator erase(iterator position);
V     iterator erase(iterator first, iterator last);
V     basic_string& replace(size_type pos1, size_type n1,
                            const basic_string& str);
V     basic_string& replace(size_type pos1, size_type n1,
                            const basic_string& str,
                            size_type pos2, size_type n2);
V     basic_string& replace(size_type pos, size_type n1, const charT* s,
                            size_type n2);
V     basic_string& replace(size_type pos, size_type n1, const charT* s);
V     basic_string& replace(size_type pos, size_type n1, size_type n2,
                            charT c);
V     basic_string& replace(iterator i1, iterator i2, const basic_string& str);
V     basic_string& replace(iterator i1, iterator i2, const charT* s,
                            size_type n);
V     basic_string& replace(iterator i1, iterator i2, const charT* s);
V     basic_string& replace(iterator i1, iterator i2,
                            size_type n, charT c);
V     template<class InputIterator>
        basic_string& 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<charT,traits,Allocator>&);
      // _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& 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& 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& 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& 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& 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& 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& str) const;
V     int compare(size_type pos1, size_type n1,
                  const basic_string& str) const;
V     int compare(size_type pos1, size_type n1,
                  const basic_string& 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 <cctype> synopsis

            isalnum   isdigit   isprint   isupper    tolower
X           isalpha   isgraph   ispunct   isxdigit   toupper
            iscntrl   islower   isspace

                   Table 11--Header <cwctype> synopsis

X  Macro:     WEOF <cwctype>
X  Types:     wctrans_t   wctype_t   wint_t <cwctype>
   Functions:
X  iswalnum   iswctype    iswlower   iswspace    towctrans   wctrans
X  iswalpha   iswdigit    iswprint   iswupper    towlower    wctype
X  iswcntrl   iswgraph    iswpunct   iswxdigit   towupper

                   Table 12--Header <cstring> synopsis

X           Macro:    NULL <cstring>
X           Type:     size_t <cstring>
            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 <cwchar> synopsis
   Macros:    NULL <cwchar>   WCHAR_MAX         WCHAR_MIN   WEOF <cwchar>
   Types:     mbstate_t       wint_t <cwchar>   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 <cstdlib> 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 <locale> synopsis

    // _lib.locale_, locale:
T   class locale;
T   template <class Facet> const Facet& use_facet(const locale&);
T   template <class Facet> bool         has_facet(const locale&) throw();

    // _lib.locale.convenience_, convenience interfaces:
T   template <class charT> bool isspace (charT c, const locale& loc);
T   template <class charT> bool isprint (charT c, const locale& loc);
T   template <class charT> bool iscntrl (charT c, const locale& loc);
T   template <class charT> bool isupper (charT c, const locale& loc);
T   template <class charT> bool islower (charT c, const locale& loc);
T   template <class charT> bool isalpha (charT c, const locale& loc);
T   template <class charT> bool isdigit (charT c, const locale& loc);
T   template <class charT> bool ispunct (charT c, const locale& loc);
T   template <class charT> bool isxdigit(charT c, const locale& loc);
T   template <class charT> bool isalnum (charT c, const locale& loc);
T   template <class charT> bool isgraph (charT c, const locale& loc);
T   template <class charT> charT toupper(charT c, const locale& loc);
T   template <class charT> charT tolower(charT c, const locale& loc);
    // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype:
    class ctype_base;
T   template <class charT> class ctype;
T   template <>            class ctype<char>;             // specialization
S   template <class charT> class ctype_byname;
S   template <>            class ctype_byname<char>;      // specialization
T   class codecvt_base;
X   template <class internT, class externT, class stateT> class codecvt;
S   template <class internT, class externT, class stateT> class codecvt_byname;
    // _lib.category.numeric_ and _lib.facet.numpunct_, numeric:
X   template <class charT, class InputIterator>  class num_get;
X   template <class charT, class OutputIterator> class num_put;
T   template <class charT> class numpunct;
S   template <class charT> class numpunct_byname;
    // _lib.category.collate_, collation:
T   template <class charT> class collate;
S   template <class charT> class collate_byname;
    // _lib.category.time_, date and time:
T   class time_base;
S   template <class charT, class InputIterator>  class time_get;
S   template <class charT, class InputIterator>  class time_get_byname;
S   template <class charT, class OutputIterator> class time_put;
S   template <class charT, class OutputIterator> class time_put_byname;
    // _lib.category.monetary_, money:
T   class money_base;
S   template <class charT, class InputIterator>  class money_get;
S   template <class charT, class OutputIterator> class money_put;
S   template <class charT, bool Intl> class moneypunct;
S   template <class charT, bool Intl> class moneypunct_byname;
    // _lib.category.messages_, message retrieval:
T   class messages_base;
S   template <class charT> class messages;
S   template <class charT> 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& other) throw()
X     explicit locale(const char* std_name);
X     locale(const locale& other, const char* std_name, category);
T     template <class Facet> locale(const locale& other, Facet* f);
T     locale(const locale& other, const locale& one, category);
T    ~locale() throw();           // non-virtual
T     const locale& operator=(const locale& other) throw();
T     template <class Facet> locale combine(const locale& other) const;
      // locale operations:
X     basic_string<char>                  name() const;
T     bool operator==(const locale& other) const;
T     bool operator!=(const locale& other) const;
T     template <class charT, class Traits, class Allocator>
        bool operator()(const basic_string<charT,Traits,Allocator>& s1,
                        const basic_string<charT,Traits,Allocator>& s2) const;
      // global locale objects:
T     static       locale  global(const locale&);
T     static const locale& 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<char>, collate<wchar_t>
T     ctype<char>, ctype<wchar_t>
T     codecvt<char,char,mbstate_t>,
S     codecvt<wchar_t,char,mbstate_t>
T     moneypunct<char>, moneypunct<wchar_t>
T     moneypunct<char,true>, moneypunct<wchar_t,true>,
S     money_get<char>, money_get<wchar_t
S     money_put<char>, money_put<wchar_t>
T     numpunct<char>, numpunct<wchar_t>,
X     num_get<char>, num_get<wchar_t>
X     num_put<char>, num_put<wchar_t>
S     time_get<char>, time_get<wchar_t>,
S     time_put<char>, time_put<wchar_t>
S     messages<char>, messages<wchar_t>

      [required instantiations]
S    collate_byname<char>, collate_byname<wchar_t>
S    ctype_byname<char>, ctype_byname<wchar_t>
S    codecvt_byname<char,char,mbstate_t>,
S    codecvt_byname<wchar_t,char,mbstate_t>
S    moneypunct_byname<char,International>,
S    moneypunct_byname<wchar_t,International>,
S    money_get<C,InputIterator>,
S    money_put<C,OutputIterator>
S    numpunct_byname<char>, numpunct_byname<wchar_t>
X    num_get<C,InputIterator>, num_put<C,OutputIterator>
S    time_get<char,InputIterator>,
S    time_get_byname<char,InputIterator>,
S    time_get<wchar_t,OutputIterator>,
S    time_get_byname<wchar_t,OutputIterator>,
S    time_put<char,OutputIterator>,
S    time_put_byname<char,OutputIterator>,
S    time_put<wchar_t,OutputIterator>
S    time_put_byname<wchar_t,OutputIterator>
S    messages_byname<char>, messages_byname<wchar_t>


   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&);                // not defined
T     void operator=(const facet&);       // 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&);  // not defined
T     id(const id&);              // 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 <class charT>
    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 <class charT>
    class ctype_byname : public ctype<charT> {
    public:
T     typedef ctype<charT>::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 <> class ctype<char>
      : 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<char>

X   template <> class ctype_byname<char> : public ctype<char> {
    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 <class internT, class externT, class stateT>
   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& state,
     const internT* from, const internT* from_end, const internT*& from_next,
           externT*   to,       externT* to_limit, externT*& to_next) const;
T   result unshift(stateT& state,
           externT*   to,        externT* to_limit, externT*& to_next) const;
T   result in(stateT& state,
     const externT* from, const externT* from_end, const externT*& from_next,
           internT*   to,       internT* to_limit, internT*& to_next) const;
T   int encoding() const throw();
T   bool always_noconv() const throw();
T   int length(const stateT&, 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& state,
     const internT* from, const internT* from_end, const internT*& from_next,
           externT* to,         externT* to_limit, externT*& to_next) const;
T   virtual result do_in(stateT& state,
T    const externT* from, const externT* from_end, const externT*& from_next,
           internT* to,         internT* to_limit, internT*& to_next) const;
T   virtual result do_unshift(stateT& state,
           externT* to,         externT* to_limit, externT*& 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&, 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 <class internT, class externT, class stateT>
   class codecvt_byname : public codecvt<internT, externT, stateT> {
   public:
S   explicit codecvt_byname(const char*, size_t refs = 0);
   protected:
S  ~codecvt_byname();             // virtual
S   virtual result do_out(stateT& state,
      const internT* from, const internT* from_end, const internT*& from_next,
            externT* to,         externT* to_limit, externT*& to_next) const;
S   virtual result do_in(stateT& state,
      const externT* from, const externT* from_end, const externT*& from_next,
            internT* to,         internT* to_limit, internT*& to_next) const;
S   virtual result do_unshift(stateT& state,
            externT* to,         externT* to_limit, externT*& 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&, const externT* from,
                          const externT* end, size_t max) const;
S   virtual result do_unshift(stateT& state,
           externT* to, externT* to_limit, externT*& 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 <class charT, class InputIterator = istreambuf_iterator<charT> >
    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&,
                    ios_base::iostate& err, bool& v)           const;
T     iter_type get(iter_type in, iter_type end, ios_base& ,
                    ios_base::iostate& err, long& v)           const;
T     iter_type get(iter_type in, iter_type end, ios_base&,
                    ios_base::iostate& err, unsigned short& v) const;
T     iter_type get(iter_type in, iter_type end, ios_base&,
                    ios_base::iostate& err, unsigned int& v)   const;
T     iter_type get(iter_type in, iter_type end, ios_base&,
                    ios_base::iostate& err, unsigned long& v)  const;
T     iter_type get(iter_type in, iter_type end, ios_base&,
                    ios_base::iostate& err, float& v)          const;
T     iter_type get(iter_type in, iter_type end, ios_base&,
                    ios_base::iostate& err, double& v)         const;
T     iter_type get(iter_type in, iter_type end, ios_base&,
                    ios_base::iostate& err, long double& v)    const;
T     iter_type get(iter_type in, iter_type end, ios_base&,
                    ios_base::iostate& err, void*& v)          const;
T     static locale::id id;

    protected:
T    ~num_get();                  // virtual
T     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, bool& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, long& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, unsigned short& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, unsigned int& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, unsigned long& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, float& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, double& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, long double& v) const;
S     virtual iter_type do_get(iter_type, iter_type, ios_base&,
          ios_base::iostate& err, void*& v) const;
    };



   22.2.2.2  Template class num_put                   [lib.locale.nm.put]

X   template <class charT, class OutputIterator = ostreambuf_iterator<charT> >
    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& f, char_type fill, bool v) const;
T     iter_type put(iter_type s, ios_base& f, char_type fill, long v) const;
T     iter_type put(iter_type s, ios_base& f, char_type fill,
                    unsigned long v) const;
T     iter_type put(iter_type s, ios_base& f, char_type fill,
                    double v) const;
T     iter_type put(iter_type s, ios_base& f, char_type fill,
                    long double v) const;
T     iter_type put(iter_type s, ios_base& 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&, char_type fill,
                               bool v) const;
T     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                               long v) const;
T     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                               unsigned long) const;
S     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                               double v) const;
S     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                               long double v) const;
T     virtual iter_type do_put(iter_type, ios_base&, char_type fill,
                               const void* v) const;
    };
   }

   22.2.3.1  Template class numpunct                [lib.locale.numpunct]

T   template <class charT>
    class numpunct : public locale::facet {
    public:
T     typedef charT               char_type;
T     typedef basic_string<charT> 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 <class charT>
    class numpunct_byname : public numpunct<charT> {
   // this class is specialized for char and wchar_t.
    public:
T     typedef charT                char_type;
T     typedef basic_string<charT>  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 <class charT>
    class collate : public locale::facet {
    public:
T     typedef charT               char_type;
T     typedef basic_string<charT> 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 <class charT>
    class collate_byname : public collate<charT> {
    public:
T     typedef basic_string<charT> 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 <class charT, class InputIterator = istreambuf_iterator<charT> >
    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& f,
                         ios_base::iostate& err, tm* t)  const;
T     iter_type get_date(iter_type s, iter_type end, ios_base& f,
                         ios_base::iostate& err, tm* t)  const;
T     iter_type get_weekday(iter_type s, iter_type end, ios_base& f,
                            ios_base::iostate& err, tm* t) const;
T     iter_type get_monthname(iter_type s, iter_type end, ios_base& f,
                              ios_base::iostate& err, tm* t) const;
T     iter_type get_year(iter_type s, iter_type end, ios_base& f,
                         ios_base::iostate& 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&,
                                    ios_base::iostate& err, tm* t) const;
S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&,
                                    ios_base::iostate& err, tm* t) const;
S     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&,
                                       ios_base::iostate& err, tm* t) const;
S     virtual iter_type do_get_monthname(iter_type s, ios_base&,
                                         ios_base::iostate& err, tm* t) const;
S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&,
                                    ios_base::iostate& err, tm* t) const;
    };



   22.2.5.2  Template class                  [lib.locale.time.get.byname]
       time_get_byname

X   template <class charT, class InputIterator = istreambuf_iterator<charT> >
    class time_get_byname : public time_get<charT, InputIterator> {
    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&,
                                    ios_base::iostate& err, tm* t) const;
S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&,
                                    ios_base::iostate& err, tm* t) const;
T     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&,
                                       ios_base::iostate& err, tm* t) const;
T     virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&,
                                         ios_base::iostate& err, tm* t) const;
S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&,
                                    ios_base::iostate& err, tm* t) const;
    };
   }

   22.2.5.3  Template class time_put                [lib.locale.time.put]

X   template <class charT, class OutputIterator = ostreambuf_iterator<charT> >
    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& f, char_type fill, const tm* tmb,
                    const charT* pattern, const charT* pat_end) const;
T     iter_type put(iter_type s, ios_base& 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&, 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 <class charT, class OutputIterator = ostreambuf_iterator<charT> >
    class time_put_byname : public time_put<charT, OutputIterator>
    {
    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&, char_type, const tm* t,
                               char format, char modifier) const;
    };


   22.2.6.1  Template class money_get              [lib.locale.money.get]

X   template <class charT,
              class InputIterator = istreambuf_iterator<charT> >
    class money_get : public locale::facet {
    public:
T     typedef charT               char_type;
T     typedef InputIterator       iter_type;
T     typedef basic_string<charT> string_type;
T     explicit money_get(size_t refs = 0);
T     iter_type get(iter_type s, iter_type end, bool intl,
                    ios_base& f, ios_base::iostate& err,
                    long double& units) const;
T     iter_type get(iter_type s, iter_type end, bool intl,
                    ios_base& f, ios_base::iostate& err,
                    string_type& 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&,
                       ios_base::iostate& err, long double& units) const;
S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&,
                       ios_base::iostate& err, string_type& digits) const;
    };

   22.2.6.2  Template class money_put              [lib.locale.money.put]

X   template <class charT,
              class OutputIterator = ostreambuf_iterator<charT> >
    class money_put : public locale::facet {
    public:
T     typedef charT               char_type;
T     typedef OutputIterator      iter_type;
T     typedef basic_string<charT> string_type;
T     explicit money_put(size_t refs = 0);
T     iter_type put(iter_type s, bool intl, ios_base& f,
                    char_type fill, long double units) const;
T     iter_type put(iter_type s, bool intl, ios_base& f,
                    char_type fill, const string_type& digits) const;
T     static locale::id id;

    protected:
T    ~money_put();                // virtual
S     virtual iter_type
        do_put(iter_type, bool, ios_base&, char_type fill,
               long double units) const;
S     virtual iter_type
        do_put(iter_type, bool, ios_base&, char_type fill,
               const string_type& 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 <class charT, bool International = false>
    class moneypunct : public locale::facet, public money_base {
    public:
T     typedef charT char_type;
T     typedef basic_string<charT> 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 <class charT, bool Intl = false>
    class moneypunct_byname : public moneypunct<charT, Intl> {
    public:
T     typedef money_base::pattern pattern;
T     typedef basic_string<charT> 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 <class charT>
    class messages : public locale::facet, public messages_base {
    public:
T     typedef charT char_type;
T     typedef basic_string<charT> string_type;
T     explicit messages(size_t refs = 0);
T     catalog open(const basic_string<char>& fn, const locale&) const;
T     string_type  get(catalog c, int set, int msgid,
                       const string_type& 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<char>&, const locale&) const;
S     virtual string_type  do_get(catalog, int set, int msgid,
                             const string_type& dfault) const;
S     virtual void    do_close(catalog) const;
    };

   22.2.7.2  Template class                  [lib.locale.messages.byname]
       messages_byname


X   template <class charT>
    class messages_byname : public messages<charT> {
    public:
T     typedef messages_base::catalog catalog;
T     typedef basic_string<charT>    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<char>&, const locale&) const;
S     virtual string_type  do_get(catalog, int set, int msgid,
                             const string_type& dfault) const;
S     virtual void    do_close(catalog) const;
    };


   22.3  C Library Locales                                [lib.c.locales]


                   Table 13--Header <clocale> 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]

   <deque>, <list>, <queue>, <stack>, and <vector>.

   Header <deque> synopsis

X   template <class T, class Allocator = allocator<T> > class deque;
T   template <class T, class Allocator>
      bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
   }

   Header <list> synopsis

X   template <class T, class Allocator = allocator<T> > class list;
T   template <class T, class Allocator>
      bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      void swap(list<T,Allocator>& x, list<T,Allocator>& y);
   }

   Header <queue> synopsis

   namespace std {
X   template <class T, class Container = deque<T> > class queue;
T   template <class T, class Container>
      bool operator==(const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator< (const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator!=(const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator> (const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator>=(const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator<=(const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container = vector<T>,
              class Compare = less<typename Container::value_type> >
T   class priority_queue;
   }

   Header <stack> synopsis

   namespace std {
T   template <class T, class Container = deque<T> > class stack;
T   template <class T, class Container>
      bool operator==(const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator< (const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator!=(const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator> (const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator>=(const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator<=(const stack<T, Container>& x,
                      const stack<T, Container>& y);
   }

   Header <vector> synopsis

T   template <class T, class Allocator = allocator<T> > class vector;

T   template <class T, class Allocator>
      bool operator==(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator< (const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator!=(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator> (const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator>=(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator<=(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);

T   template <class Allocator> class vector<bool,Allocator>;
T   template <class Allocator>
      bool operator==(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator< (const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator!=(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator> (const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator>=(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator<=(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      void swap(vector<bool,Allocator>& x, vector<bool,Allocator>& y);
   }

   23.2.1  Template class deque                               [lib.deque]

    template <class T, class Allocator = allocator<T> >
X   class deque {
    public:
      // types:
T     typedef typename Allocator::reference         reference;
T     typedef typename Allocator::const_reference   const_reference;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      // _lib.deque.cons_ construct/copy/destroy:
T     explicit deque(const Allocator& = Allocator());
T     explicit deque(size_type n, const T& value = T(),
          const Allocator& = Allocator());
T     template <class InputIterator>
        deque(InputIterator first, InputIterator last,
              const Allocator& = Allocator());
T     deque(const deque<T,Allocator>& x);
T    ~deque();
T     deque<T,Allocator>& operator=(const deque<T,Allocator>& x);
T     template <class InputIterator>
        void assign(InputIterator first, InputIterator last);
T     void assign(size_type n, const T& 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& x);
T     void push_back(const T& x);
T     iterator insert(iterator position, const T& x);
T     void     insert(iterator position, size_type n, const T& x);
T     template <class InputIterator>
        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<T,Allocator>&);
T     void     clear();
    };
T   template <class T, class Allocator>
      bool operator==(const deque<T,Allocator>& x,
                      const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator< (const deque<T,Allocator>& x,
                      const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator!=(const deque<T,Allocator>& x,
                      const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator> (const deque<T,Allocator>& x,
                      const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator>=(const deque<T,Allocator>& x,
                      const deque<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator<=(const deque<T,Allocator>& x,
                      const deque<T,Allocator>& y);
    // specialized algorithms:
T   template <class T, class Allocator>
      void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);


   23.2.2  Template class list                                 [lib.list]

X   template <class T, class Allocator = allocator<T> >
    class list {
    public:
      // types:
T     typedef typename Allocator::reference         reference;
T     typedef typename Allocator::const_reference   const_reference;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

      // _lib.list.cons_ construct/copy/destroy:
T     explicit list(const Allocator& = Allocator());
T     explicit list(size_type n, const T& value = T(),
                    const Allocator& = Allocator());
T     template <class InputIterator>
        list(InputIterator first, InputIterator last,
             const Allocator& = Allocator());
T     list(const list<T,Allocator>& x);
T    ~list();
T     list<T,Allocator>& operator=(const list<T,Allocator>& x);
T     template <class InputIterator>
        void assign(InputIterator first, InputIterator last);
T     void assign(size_type n, const T& 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& x);
T     void pop_front();
T     void push_back(const T& x);
T     void pop_back();
T     iterator insert(iterator position, const T& x);
T     void     insert(iterator position, size_type n, const T& x);
T     template <class InputIterator>
        void insert(iterator position, InputIterator first,
                    InputIterator last);
T     iterator erase(iterator position);
T     iterator erase(iterator position, iterator last);
T     void     swap(list<T,Allocator>&);
T     void     clear();
      // _lib.list.ops_ list operations:
T     void splice(iterator position, list<T,Allocator>& x);
T     void splice(iterator position, list<T,Allocator>& x, iterator i);
T     void splice(iterator position, list<T,Allocator>& x, iterator first,
                  iterator last);
T     void remove(const T& value);
T     template <class Predicate> void remove_if(Predicate pred);

T     void unique();
T     template <class BinaryPredicate>
        void unique(BinaryPredicate binary_pred);
T     void merge(list<T,Allocator>& x);
T     template <class Compare> void merge(list<T,Allocator>& x, Compare comp);
        void sort();
T     template <class Compare> void sort(Compare comp);
        void reverse();
    };
T   template <class T, class Allocator>
      bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y);
    // specialized algorithms:
T   template <class T, class Allocator>
      void swap(list<T,Allocator>& x, list<T,Allocator>& y);


   23.2.3.1  Template class queue                             [lib.queue]

T   template <class T, class Container = deque<T> >
    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& = Container());

T     bool      empty() const             { return c.empty(); }
T     size_type size()  const             { return c.size(); }
T     value_type&       front()           { return c.front(); }
T     const value_type& front() const     { return c.front(); }
T     value_type&       back()            { return c.back(); }
T     const value_type& back() const      { return c.back(); }
T     void push(const value_type& x)      { c.push_back(x); }
T     void pop()                          { c.pop_front(); }
    };

T   template <class T, class Container>
      bool operator==(const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator< (const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator!=(const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator> (const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator>=(const queue<T, Container>& x,
                      const queue<T, Container>& y);
T   template <class T, class Container>
      bool operator<=(const queue<T, Container>& x,
                      const queue<T, Container>& y);

   23.2.3.2  Template class priority_queue           [lib.priority.queue]

T   template <class T, class Container = vector<T>,
              class Compare = less<typename Container::value_type> >
    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& x = Compare(),
                              const Container& = Container());
T     template <class InputIterator>
        priority_queue(InputIterator first, InputIterator last,
                       const Compare& x = Compare(),
                       const Container& = Container());

T     bool      empty() const       { return c.empty(); }
T     size_type size()  const       { return c.size(); }
T     const value_type& top() const { return c.front(); }
T     void push(const value_type& x);
T     void pop();
    };

   23.2.3.3  Template class stack                             [lib.stack]

T   template <class T, class Container = deque<T> >
    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& = Container());

T     bool      empty() const             { return c.empty(); }
T     size_type size()  const             { return c.size(); }
T     value_type&       top()             { return c.back(); }
T     const value_type& top() const       { return c.back(); }
T     void push(const value_type& x)      { c.push_back(x); }
T     void pop()                          { c.pop_back(); }
    };
T   template <class T, class Container>
      bool operator==(const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator< (const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator!=(const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator> (const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator>=(const stack<T, Container>& x,
                      const stack<T, Container>& y);
T   template <class T, class Container>
      bool operator<=(const stack<T, Container>& x,
                      const stack<T, Container>& y);

   23.2.4  Template class vector                             [lib.vector]

    template <class T, class Allocator = allocator<T> >
X   class vector {
    public:
      // types:
T     typedef typename Allocator::reference         reference;
T     typedef typename Allocator::const_reference   const_reference;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      // _lib.vector.cons_ construct/copy/destroy:
T     explicit vector(const Allocator& = Allocator());
T     explicit vector(size_type n, const T& value = T(),
          const Allocator& = Allocator());
T     template <class InputIterator>
        vector(InputIterator first, InputIterator last,
          const Allocator& = Allocator());
T     vector(const vector<T,Allocator>& x);
T    ~vector();
T     vector<T,Allocator>& operator=(const vector<T,Allocator>& x);
T     template <class InputIterator>
        void assign(InputIterator first, InputIterator last);
T     void assign(size_type n, const T& 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& x);
T     void pop_back();
T     iterator insert(iterator position, const T& x);
T     void     insert(iterator position, size_type n, const T& x);
T     template <class InputIterator>
          void insert(iterator position,
                      InputIterator first, InputIterator last);
T     iterator erase(iterator position);
T     iterator erase(iterator first, iterator last);
T     void     swap(vector<T,Allocator>&);
T     void     clear();
    };

T   template <class T, class Allocator>
      bool operator==(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator< (const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator!=(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator> (const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator>=(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
T   template <class T, class Allocator>
      bool operator<=(const vector<T,Allocator>& x,
                      const vector<T,Allocator>& y);
    // specialized algorithms:
T   template <class T, class Allocator>
      void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);


   23.2.5  Class vector<bool>                           [lib.vector.bool]

X   template <class Allocator> class vector<bool, Allocator> {
    public:
      // types:
T     typedef bool                                  const_reference;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      // bit reference:
T     class reference {
       friend class vector;
T      reference();
      public:
T      ~reference();
T       operator bool() const;
T       reference& operator=(const bool x);
T       reference& operator=(const reference& x);
T       void flip();              // flips the bit
      };

      // construct/copy/destroy:
T     explicit vector(const Allocator& = Allocator());
T     explicit vector(size_type n, const bool& value = bool(),
                      const Allocator& = Allocator());
T     template <class InputIterator>
        vector(InputIterator first, InputIterator last,
          const Allocator& = Allocator());
T     vector(const vector<bool,Allocator>& x);
T    ~vector();
T     vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x);
T     template <class InputIterator>
        void assign(InputIterator first, InputIterator last);
T     void assign(size_type n, const T& 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& x);
T     void pop_back();
T     iterator insert(iterator position, const bool& x);
T     void     insert (iterator position, size_type n, const bool& x);
T     template <class InputIterator>
          void insert(iterator position,
                      InputIterator first, InputIterator last);
T     iterator erase(iterator position);
T     iterator erase(iterator first, iterator last);
T     void swap(vector<bool,Allocator>&);
T     static void swap(reference x, reference y);
T     void flip();                // flips all bits
T     void clear();
    };

T   template <class Allocator>
      bool operator==(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator< (const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator!=(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator> (const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator>=(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
T   template <class Allocator>
      bool operator<=(const vector<bool,Allocator>& x,
                      const vector<bool,Allocator>& y);
    // specialized algorithms:
T   template <class Allocator>
      void swap(vector<bool,Allocator>& x, vector<bool,Allocator>& y);

   23.3  Associative containers                         [lib.associative]

 <map> and <set>:

   Header <map> synopsis

    template <class Key, class T, class Compare = less<Key>,
              class Allocator = allocator<pair<const Key, T> > >
X     class map;

T   template <class Key, class T, class Compare, class Allocator>
      bool operator==(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator< (const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator!=(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator> (const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator>=(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator<=(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      void swap(map<Key,T,Compare,Allocator>& x,
                map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare = less<Key>,
              class Allocator = allocator<pair<const Key, T> > >
      class multimap;
T   template <class Key, class T, class Compare, class Allocator>
      bool operator==(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator< (const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator> (const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      void swap(multimap<Key,T,Compare,Allocator>& x,
                multimap<Key,T,Compare,Allocator>& y);
   }

   Header <set> synopsis

    template <class Key, class Compare = less<Key>,
              class Allocator = allocator<Key> >
X     class set;

T   template <class Key, class Compare, class Allocator>
      bool operator==(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator< (const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator!=(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator> (const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator>=(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator<=(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      void swap(set<Key,Compare,Allocator>& x,
                set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare = less<Key>,
              class Allocator = allocator<Key> >
      class multiset;
T   template <class Key, class Compare, class Allocator>
      bool operator==(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator< (const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator!=(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator> (const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator>=(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator<=(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      void swap(multiset<Key,Compare,Allocator>& x,
                multiset<Key,Compare,Allocator>& y);
   }

   23.3.1  Template class map                                   [lib.map]

    template <class Key, class T, class Compare = less<Key>,
              class Allocator = allocator<pair<const Key, T> > >
X     class map {
    public:
      // types:
T     typedef Key                                   key_type;
T     typedef T                                     mapped_type;
T     typedef pair<const Key, T>                    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;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
T     class value_compare
        : public binary_function<value_type,value_type,bool> {
      friend class map;
      protected:
T       Compare comp;
T       value_compare(Compare c) : comp(c) {}
      public:
T       bool operator()(const value_type& x, const value_type& y) const {
          return comp(x.first, y.first);
        }
      };

      // _lib.map.cons_ construct/copy/destroy:
T     explicit map(const Compare& comp = Compare(),
                   const Allocator& = Allocator());
T     template <class InputIterator>
        map(InputIterator first, InputIterator last,
            const Compare& comp = Compare(), const Allocator& = Allocator());
T     map(const map<Key,T,Compare,Allocator>& x);
T    ~map();
T     map<Key,T,Compare,Allocator>&
        operator=(const map<Key,T,Compare,Allocator>& 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& operator[](const key_type& x);
      // modifiers:
T     pair<iterator, bool> insert(const value_type& x);
T     iterator             insert(iterator position, const value_type& x);
T     template <class InputIterator>
        void insert(InputIterator first, InputIterator last);
T     void      erase(iterator position);
T     size_type erase(const key_type& x);
T     void      erase(iterator first, iterator last);
T     void swap(map<Key,T,Compare,Allocator>&);
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& x);
T     const_iterator find(const key_type& x) const;
T     size_type      count(const key_type& x) const;
T     iterator       lower_bound(const key_type& x);
T     const_iterator lower_bound(const key_type& x) const;
T     iterator       upper_bound(const key_type& x);
T     const_iterator upper_bound(const key_type& x) const;
T     pair<iterator,iterator>
          equal_range(const key_type& x);
T     pair<const_iterator,const_iterator>
          equal_range(const key_type& x) const;
    };

T   template <class Key, class T, class Compare, class Allocator>
      bool operator==(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator< (const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator!=(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator> (const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator>=(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator<=(const map<Key,T,Compare,Allocator>& x,
                      const map<Key,T,Compare,Allocator>& y);
    // specialized algorithms:
T   template <class Key, class T, class Compare, class Allocator>
      void swap(map<Key,T,Compare,Allocator>& x,
                map<Key,T,Compare,Allocator>& y);

   23.3.2  Template class multimap                         [lib.multimap]

    template <class Key, class T, class Compare = less<Key>,
              class Allocator = allocator<pair<const Key, T> > >
X   class multimap {
    public:
      // types:
T     typedef Key                                   key_type;
T     typedef T                                     mapped_type;
T     typedef pair<const Key,T>                     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;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
T     class value_compare
        : public binary_function<value_type,value_type,bool> {
      friend class multimap;
      protected:
T       Compare comp;
T       value_compare(Compare c) : comp(c) {}
      public:
T       bool operator()(const value_type& x, const value_type& y) const {
          return comp(x.first, y.first);
        }
      };
      // construct/copy/destroy:
T     explicit multimap(const Compare& comp = Compare(),
                        const Allocator& = Allocator());
T     template <class InputIterator>
        multimap(InputIterator first, InputIterator last,
                 const Compare& comp = Compare(),
                 const Allocator& = Allocator());
T     multimap(const multimap<Key,T,Compare,Allocator>& x);
T    ~multimap();
T     multimap<Key,T,Compare,Allocator>&
        operator=(const multimap<Key,T,Compare,Allocator>& 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& x);
T     iterator insert(iterator position, const value_type& x);
T     template <class InputIterator>
        void insert(InputIterator first, InputIterator last);
T     void      erase(iterator position);
T     size_type erase(const key_type& x);
T     void      erase(iterator first, iterator last);
T     void swap(multimap<Key,T,Compare,Allocator>&);
T     void clear();
      // observers:
T     key_compare    key_comp() const;
T     value_compare  value_comp() const;
      // map operations:
T     iterator       find(const key_type& x);
T     const_iterator find(const key_type& x) const;
T     size_type      count(const key_type& x) const;
T     iterator       lower_bound(const key_type& x);
T     const_iterator lower_bound(const key_type& x) const;
T     iterator       upper_bound(const key_type& x);
T     const_iterator upper_bound(const key_type& x) const;
T     pair<iterator,iterator>             equal_range(const key_type& x);
T     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
    };

T   template <class Key, class T, class Compare, class Allocator>
      bool operator==(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator< (const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator> (const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
T   template <class Key, class T, class Compare, class Allocator>
      bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
                      const multimap<Key,T,Compare,Allocator>& y);
    // specialized algorithms:
T   template <class Key, class T, class Compare, class Allocator>
      void swap(multimap<Key,T,Compare,Allocator>& x,
                multimap<Key,T,Compare,Allocator>& y);


   23.3.3  Template class set                                   [lib.set]

    template <class Key, class Compare = less<Key>,
              class Allocator = allocator<Key> >
X   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;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      // _lib.set.cons_ construct/copy/destroy:
T     explicit set(const Compare& comp = Compare(),
                   const Allocator& = Allocator());
T     template <class InputIterator>
        set(InputIterator first, InputIterator last,
            const Compare& comp = Compare(), const Allocator& = Allocator());
T     set(const set<Key,Compare,Allocator>& x);
T    ~set();
T     set<Key,Compare,Allocator>&
        operator=(const set<Key,Compare,Allocator>& 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<iterator,bool> insert(const value_type& x);
T     iterator            insert(iterator position, const value_type& x);
T     template <class InputIterator>
T         void insert(InputIterator first, InputIterator last);
T     void      erase(iterator position);
T     size_type erase(const key_type& x);
T     void      erase(iterator first, iterator last);
T     void swap(set<Key,Compare,Allocator>&);
T     void clear();

      // observers:
T     key_compare   key_comp() const;
T     value_compare value_comp() const;
      // set operations:
T     iterator  find(const key_type& x) const;
T     size_type count(const key_type& x) const;
T     iterator  lower_bound(const key_type& x) const;
T     iterator  upper_bound(const key_type& x) const;
T     pair<iterator,iterator> equal_range(const key_type& x) const;
    };
T   template <class Key, class Compare, class Allocator>
      bool operator==(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator< (const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator!=(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator> (const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator>=(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator<=(const set<Key,Compare,Allocator>& x,
                      const set<Key,Compare,Allocator>& y);
    // specialized algorithms:
T   template <class Key, class Compare, class Allocator>
      void swap(set<Key,Compare,Allocator>& x,
                set<Key,Compare,Allocator>& y);

   23.3.4  Template class multiset                         [lib.multiset]

    template <class Key, class Compare = less<Key>,
              class Allocator = allocator<Key> >
X   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;
X     typedef implementation defined                iterator;
X     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<iterator>       reverse_iterator;
T     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

      // construct/copy/destroy:
T     explicit multiset(const Compare& comp = Compare(),
                        const Allocator& = Allocator());
T     template <class InputIterator>
        multiset(InputIterator first, InputIterator last,
                 const Compare& comp = Compare(),
                 const Allocator& = Allocator());
T     multiset(const multiset<Key,Compare,Allocator>& x);
T    ~multiset();
T     multiset<Key,Compare,Allocator>&
          operator=(const multiset<Key,Compare,Allocator>& 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& x);
T     iterator insert(iterator position, const value_type& x);
T     template <class InputIterator>
        void insert(InputIterator first, InputIterator last);
T     void      erase(iterator position);
T     size_type erase(const key_type& x);
T     void      erase(iterator first, iterator last);
T     void swap(multiset<Key,Compare,Allocator>&);
T     void clear();
      // observers:
T     key_compare   key_comp() const;
T     value_compare value_comp() const;
      // set operations:
T     iterator  find(const key_type& x) const;
T     size_type count(const key_type& x) const;
T     iterator  lower_bound(const key_type& x) const;
T     iterator  upper_bound(const key_type& x) const;
T     pair<iterator,iterator> equal_range(const key_type& x) const;
    };

T   template <class Key, class Compare, class Allocator>
      bool operator==(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator< (const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator!=(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator> (const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator>=(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
T   template <class Key, class Compare, class Allocator>
      bool operator<=(const multiset<Key,Compare,Allocator>& x,
                      const multiset<Key,Compare,Allocator>& y);
    // specialized algorithms:
T   template <class Key, class Compare, class Allocator>
      void swap(multiset<Key,Compare,Allocator>& x,
                multiset<Key,Compare,Allocator>& y);

   23.3.5  Template class bitset                    [lib.template.bitset]

   Header <bitset> synopsis

   [What's this stuff?
   #include <cstddef>              // for size_t
   #include <string>
   #include <stdexcept>            // for invalid_argument,
                                  //     out_of_range, overflow_error
   #include <iosfwd>               // for istream, ostream
   ]
X   template <size_t N> class bitset;
    // _lib.bitset.operators_ bitset operations:
T   template <size_t N>
      bitset<N> operator&(const bitset<N>&, const bitset<N>&);
T   template <size_t N>
      bitset<N> operator|(const bitset<N>&, const bitset<N>&);
T   template <size_t N>
      bitset<N> operator^(const bitset<N>&, const bitset<N>&);
T   template <class charT, class traits, size_t N>
      basic_istream<charT, traits>&
      operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
T   template <class charT, class traits, size_t N>
      basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);

X   template<size_t N> class bitset {
    public:
      // bit reference:
T     class reference {
        friend class bitset;
T       reference();
      public:
T      ~reference();
T       reference& operator=(bool x);             // for b[i] = x;
T       reference& operator=(const reference&);   // for b[i] = b[j];
T       bool operator~() const;                   // flips the bit
T       operator bool() const;                    // for x = b[i];
T       reference& flip();                        // for b[i].flip();
      };

      // _lib.bitset.cons_ constructors:
T     bitset();
T     bitset(unsigned long val);
T     template<class charT, class traits, class Allocator>
        explicit bitset(
          const basic_string<charT,traits,Allocator>& str,
          typename basic_string<charT,traits,Allocator>::size_type pos = 0,
          typename basic_string<charT,traits,Allocator>::size_type n =
            basic_string<charT,traits,Allocator>::npos);
      // _lib.bitset.members_ bitset operations:
T     bitset<N>& operator&=(const bitset<N>& rhs);
T     bitset<N>& operator|=(const bitset<N>& rhs);
T     bitset<N>& operator^=(const bitset<N>& rhs);
T     bitset<N>& operator<<=(size_t pos);
T     bitset<N>& operator>>=(size_t pos);
T     bitset<N>& set();
T     bitset<N>& set(size_t pos, int val = true);
T     bitset<N>& reset();
T     bitset<N>& reset(size_t pos);
T     bitset<N>  operator~() const;
T     bitset<N>& flip();
T     bitset<N>& flip(size_t pos);
      // element access:
T     reference operator[](size_t pos);         // for b[i];
T     unsigned long  to_ulong() const;
T     template <class charT, class traits, class Allocator>
        basic_string<charT, traits, Allocator> to_string() const;
T     size_t count() const;
T     size_t size()  const;
T     bool operator==(const bitset<N>& rhs) const;
T     bool operator!=(const bitset<N>& rhs) const;
T     bool test(size_t pos) const;
T     bool any() const;
T     bool none() const;
T     bitset<N> operator<<(size_t pos) const;
T     bitset<N> operator>>(size_t pos) const;
    };




   24.2  Header <iterator> synopsis               [lib.iterator.synopsis]

    // _lib.iterator.primitives_, primitives:
T   template<class Iterator> struct iterator_traits;
T   template<class T> struct iterator_traits<T*>;

X   template<class Category, class T, class Distance = ptrdiff_t,
             class Pointer = T*, class Reference = T&> 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 <class InputIterator, class Distance>
      void advance(InputIterator& i, Distance n);
T   template <class InputIterator>
      typename iterator_traits<InputIterator>::difference_type
      distance(InputIterator first, InputIterator last);
    // _lib.predef.iterators_, predefined iterators:
X   template <class Iterator> class reverse_iterator;
T   template <class Iterator>
      bool operator==(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator<(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator!=(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator>(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator>=(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator<=(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      typename reverse_iterator<Iterator>::difference_type operator-(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      reverse_iterator<Iterator>
        operator+(
          typename reverse_iterator<Iterator>::difference_type n,
          const reverse_iterator<Iterator>& x);

X   template <class Container> class back_insert_iterator;
T   template <class Container>
      back_insert_iterator<Container> back_inserter(Container& x);
X   template <class Container> class front_insert_iterator;
T   template <class Container>
      front_insert_iterator<Container> front_inserter(Container& x);
X   template <class Container> class insert_iterator;
T   template <class Container, class Iterator>
      insert_iterator<Container> inserter(Container& x, Iterator i);
    // _lib.stream.iterators_, stream iterators:
X   template <class T, class charT = char, class traits = char_traits<charT>,
              class Distance = ptrdiff_t>
      class istream_iterator;
    template <class T, class charT, class traits, class Distance>
X     bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
                      const istream_iterator<T,charT,traits,Distance>& y);
    template <class T, class charT, class traits, class Distance>
X     bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
                      const istream_iterator<T,charT,traits,Distance>& y);
X   template <class T, class charT = char, class traits = char_traits<charT> >
        class ostream_iterator;
X   template<class charT, class traits = char_traits<charT> >
      class istreambuf_iterator;
X   template <class charT, class traits>
      bool operator==(const istreambuf_iterator<charT,traits>& a,
                      const istreambuf_iterator<charT,traits>& b);
X   template <class charT, class traits>
      bool operator!=(const istreambuf_iterator<charT,traits>& a,
                      const istreambuf_iterator<charT,traits>& b);
T   template <class charT, class traits = char_traits<charT> >
      class ostreambuf_iterator;

   24.3  Iterator primitives                    [lib.iterator.primitives]

T   template<class Iterator> 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<class T> struct iterator_traits<T*> {
T     typedef ptrdiff_t difference_type;
T     typedef T value_type;
T     typedef T* pointer;
T     typedef T& reference;
T     typedef random_access_iterator_tag iterator_category;
    };

T   template<class T> struct iterator_traits<const T*> {
T     typedef ptrdiff_t difference_type;
T     typedef T value_type;
T     typedef const T* pointer;
T     typedef const T& reference;
T     typedef random_access_iterator_tag iterator_category;
    };

   24.3.2  Basic iterator                            [lib.iterator.basic]

    template<class Category, class T, class Distance = ptrdiff_t,
             class Pointer = T*, class Reference = T&>
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 <class Iterator>
X   class reverse_iterator : public
          iterator<typename iterator_traits<Iterator>::iterator_category,
                   typename iterator_traits<Iterator>::value_type,
                   typename iterator_traits<Iterator>::difference_type,
                   typename iterator_traits<Iterator>::pointer,
                   typename iterator_traits<Iterator>::reference> {
    protected:
T     Iterator current;
    public:
T     typedef Iterator
          iterator_type;
T     typedef typename iterator_traits<Iterator>::difference_type
          difference_type;
T     typedef typename iterator_traits<Iterator>::reference
          reference;
T     typedef typename iterator_traits<Iterator>::pointer
          pointer;

T     reverse_iterator();
T     explicit reverse_iterator(Iterator x);
T     template <class U> reverse_iterator(const reverse_iterator<U>& u);
T     Iterator base() const;      // explicit
T     reference operator*() const;
T     pointer   operator->() const;
T     reverse_iterator& operator++();
T     reverse_iterator  operator++(int);
T     reverse_iterator& operator--();
T     reverse_iterator  operator--(int);

T     reverse_iterator  operator+ (difference_type n) const;
T     reverse_iterator& operator+=(difference_type n);
T     reverse_iterator  operator- (difference_type n) const;
T     reverse_iterator& operator-=(difference_type n);
T     reference operator[](difference_type n) const;
    };
T   template <class Iterator>
      bool operator==(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator<(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator!=(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator>(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator>=(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      bool operator<=(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      typename reverse_iterator<Iterator>::difference_type operator-(
        const reverse_iterator<Iterator>& x,
        const reverse_iterator<Iterator>& y);
T   template <class Iterator>
      reverse_iterator<Iterator> operator+(
        typename reverse_iterator<Iterator>::difference_type n,
        const reverse_iterator<Iterator>& x);


   24.4.2.1  Template class                    [lib.back.insert.iterator]
       back_insert_iterator

    template <class Container>
X   class back_insert_iterator :
          public iterator<output_iterator_tag,void,void,void,void> {
    protected:
T     Container* container;
    public:
T     typedef Container container_type;
T     explicit back_insert_iterator(Container& x);
T     back_insert_iterator<Container>&
        operator=(typename Container::const_reference value);

T     back_insert_iterator<Container>& operator*();
T     back_insert_iterator<Container>& operator++();
T     back_insert_iterator<Container>  operator++(int);
    };
T   template <class Container>
      back_insert_iterator<Container> back_inserter(Container& x);



   24.4.2.3  Template class                   [lib.front.insert.iterator]
       front_insert_iterator

    template <class Container>
X   class front_insert_iterator :
          public iterator<output_iterator_tag,void,void,void,void> {
    protected:
T     Container* container;
    public:
T     typedef Container container_type;
T     explicit front_insert_iterator(Container& x);
T     front_insert_iterator<Container>&
        operator=(typename Container::const_reference value);
T     front_insert_iterator<Container>& operator*();
T     front_insert_iterator<Container>& operator++();
T     front_insert_iterator<Container>  operator++(int);
    };
T   template <class Container>
      front_insert_iterator<Container> front_inserter(Container& x);


   24.4.2.5  Template class insert_iterator         [lib.insert.iterator]

    template <class Container>
X   class insert_iterator :
          public iterator<output_iterator_tag,void,void,void,void> {
    protected:
T     Container* container;
T     typename Container::iterator iter;
    public:
T     typedef Container container_type;
T     insert_iterator(Container& x, typename Container::iterator i);
T     insert_iterator<Container>&
        operator=(typename Container::const_reference value);
T     insert_iterator<Container>& operator*();
T     insert_iterator<Container>& operator++();
T     insert_iterator<Container>& operator++(int);
    };
T   template <class Container, class Iterator>
      insert_iterator<Container> inserter(Container& x, Iterator i);

   24.5.1  Template class istream_iterator         [lib.istream.iterator]

    template <class T, class charT = char, class traits = char_traits<charT>,
        class Distance = ptrdiff_t>
X   class istream_iterator:
      public iterator<input_iterator_tag, T, Distance, const T*, const T&> {
    public:
T     typedef charT char_type
T     typedef traits traits_type;
T     typedef basic_istream<charT,traits> istream_type;
T     istream_iterator();
T     istream_iterator(istream_type& s);
T     istream_iterator(const istream_iterator<T,charT,traits,Distance>& x);
T    ~istream_iterator();

T     const T& operator*() const;
T     const T* operator->() const;
T     istream_iterator<T,charT,traits,Distance>& operator++();
T     istream_iterator<T,charT,traits,Distance>  operator++(int);
    };

T   template <class T, class charT, class traits, class Distance>
      bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
                      const istream_iterator<T,charT,traits,Distance>& y);
T   template <class T, class charT, class traits, class Distance>
      bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
                      const istream_iterator<T,charT,traits,Distance>& y);


   24.5.2  Template class ostream_iterator         [lib.ostream.iterator]

    template <class T, class charT = char, class traits = char_traits<charT> >
X   class ostream_iterator:
      public iterator<output_iterator_tag, void, void, void, void> {
    public:
T     typedef charT char_type;
T     typedef traits traits_type;
T     typedef basic_ostream<charT,traits> ostream_type;
T     ostream_iterator(ostream_type& s);
T     ostream_iterator(ostream_type& s, const charT* delimiter);
T     ostream_iterator(const ostream_iterator<T,charT,traits>& x);
T    ~ostream_iterator();
T     ostream_iterator<T,charT,traits>& operator=(const T& value);

T     ostream_iterator<T,charT,traits>& operator*();
T     ostream_iterator<T,charT,traits>& operator++();
T     ostream_iterator<T,charT,traits>& operator++(int);
    };


   24.5.3  Template class                       [lib.istreambuf.iterator]
       istreambuf_iterator

    template<class charT, class traits = char_traits<charT> >
X   class istreambuf_iterator
       : public iterator<input_iterator_tag, charT,
                         typename traits::off_type, charT*, charT&> {
    public:
T     typedef charT                         char_type;
T     typedef traits                        traits_type;
T     typedef typename traits::int_type     int_type;
T     typedef basic_streambuf<charT,traits> streambuf_type;
T     typedef basic_istream<charT,traits>   istream_type;
T     class proxy;                        // exposition only
T     istreambuf_iterator() throw();
T     istreambuf_iterator(istream_type& s) throw();
T     istreambuf_iterator(streambuf_type* s) throw();
T     istreambuf_iterator(const proxy& p) throw();
T     charT operator*() const;
T     istreambuf_iterator<charT,traits>& operator++();
T     proxy operator++(int);
X     bool equal(istreambuf_iterator& b);
    };

T   template <class charT, class traits>
      bool operator==(const istreambuf_iterator<charT,traits>& a,
                      const istreambuf_iterator<charT,traits>& b);

T   template <class charT, class traits>
      bool operator!=(const istreambuf_iterator<charT,traits>& a,
                      const istreambuf_iterator<charT,traits>& b);

   24.5.3.1  Template class              [lib.istreambuf.iterator::proxy]
       istreambuf_iterator::proxy

    template <class charT, class traits = char_traits<charT> >
T     class istreambuf_iterator<charT, traits>::proxy
    {
T     charT keep_;
T     basic_streambuf<charT,traits>* sbuf_;
T     proxy(charT c,
            basic_streambuf<charT,traits>* sbuf);
        : keep_(c), sbuf_(sbuf) {}
    public:
T     charT operator*() { return keep_; }
    };



   24.5.4  Template class                       [lib.ostreambuf.iterator]
       ostreambuf_iterator

    template <class charT, class traits = char_traits<charT> >
T   class ostreambuf_iterator:
      public iterator<output_iterator_tag, void, void, void, void> {
    public:
T     typedef charT                         char_type;
T     typedef traits                        traits_type;
T     typedef basic_streambuf<charT,traits> streambuf_type;
T     typedef basic_ostream<charT,traits>   ostream_type;
    public:
T     ostreambuf_iterator(ostream_type& s) throw();
T     ostreambuf_iterator(streambuf_type* s) throw();
T     ostreambuf_iterator& operator=(charT c);
T     ostreambuf_iterator& operator*();
T     ostreambuf_iterator& operator++();
T     ostreambuf_iterator& operator++(int);
T     bool failed() const throw();
    };


   Header <algorithm> synopsis


    // _lib.alg.nonmodifying_, non-modifying sequence operations:
T   template<class InputIterator, class Function>
      Function for_each(InputIterator first, InputIterator last, Function f);
T   template<class InputIterator, class T>
      InputIterator find(InputIterator first, InputIterator last,
                         const T& value);
T   template<class InputIterator, class Predicate>
      InputIterator find_if(InputIterator first, InputIterator last,
                            Predicate pred);
T   template<class ForwardIterator1, class ForwardIterator2>
      ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2);
T   template<class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate>
      ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 BinaryPredicate pred);
T   template<class ForwardIterator1, class ForwardIterator2>
      ForwardIterator1
        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
                      ForwardIterator2 first2, ForwardIterator2 last2);
T   template<class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate>
      ForwardIterator1
        find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 BinaryPredicate pred);
T   template<class ForwardIterator>
      ForwardIterator adjacent_find(ForwardIterator first,
                                    ForwardIterator last);
T   template<class ForwardIterator, class BinaryPredicate>
      ForwardIterator adjacent_find(ForwardIterator first,
          ForwardIterator last, BinaryPredicate pred);
T   template<class InputIterator, class T>
      typename iterator_traits<InputIterator>::difference_type
        count(InputIterator first, InputIterator last, const T& value);
T   template<class InputIterator, class Predicate>
      typename iterator_traits<InputIterator>::difference_type
        count_if(InputIterator first, InputIterator last, Predicate pred);
T   template<class InputIterator1, class InputIterator2>
      pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2);
T   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
      pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, BinaryPredicate pred);

T   template<class InputIterator1, class InputIterator2>
      bool equal(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2);
T   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
      bool equal(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, BinaryPredicate pred);
T   template<class ForwardIterator1, class ForwardIterator2>
      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2, ForwardIterator2 last2);
T   template<class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate>
      ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2, ForwardIterator2 last2,
                              BinaryPredicate pred);
T   template<class ForwardIterator, class Size, class T>
      ForwardIterator  search_n(ForwardIterator first, ForwardIterator last,
                              Size count, const T& value);
T   template<class ForwardIterator, class Size, class T, class BinaryPredicate>
      ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
                              Size count, const T& value,
                              BinaryPredicate pred);
    // _lib.alg.modifying.operations_, modifying sequence operations:
    // _lib.alg.copy_, copy:
T   template<class InputIterator, class OutputIterator>
      OutputIterator copy(InputIterator first, InputIterator last,
                          OutputIterator result);
T   template<class BidirectionalIterator1, class BidirectionalIterator2>
      BidirectionalIterator2
        copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
                      BidirectionalIterator2 result);
    // _lib.alg.swap_, swap:
T   template<class T> void swap(T& a, T& b);
T   template<class ForwardIterator1, class ForwardIterator2>
      ForwardIterator2 swap_ranges(ForwardIterator1 first1,
          ForwardIterator1 last1, ForwardIterator2 first2);
T   template<class ForwardIterator1, class ForwardIterator2>
      void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
T   template<class InputIterator, class OutputIterator, class UnaryOperation>
      OutputIterator transform(InputIterator first, InputIterator last,
                               OutputIterator result, UnaryOperation op);
T   template<class InputIterator1, class InputIterator2, class OutputIterator,
             class BinaryOperation>
      OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, OutputIterator result,
                               BinaryOperation binary_op);

T   template<class ForwardIterator, class T>
      void replace(ForwardIterator first, ForwardIterator last,
                   const T& old_value, const T& new_value);
T   template<class ForwardIterator, class Predicate, class T>
      void replace_if(ForwardIterator first, ForwardIterator last,
                      Predicate pred, const T& new_value);
T   template<class InputIterator, class OutputIterator, class T>
      OutputIterator replace_copy(InputIterator first, InputIterator last,
                                  OutputIterator result,
                                  const T& old_value, const T& new_value);
T   template<class Iterator, class OutputIterator, class Predicate, class T>
      OutputIterator replace_copy_if(Iterator first, Iterator last,
                                     OutputIterator result,
                                     Predicate pred, const T& new_value);
T   template<class ForwardIterator, class T>
      void fill(ForwardIterator first, ForwardIterator last, const T& value);
T   template<class OutputIterator, class Size, class T>
      void fill_n(OutputIterator first, Size n, const T& value);
T   template<class ForwardIterator, class Generator>
      void generate(ForwardIterator first, ForwardIterator last, Generator gen);
T   template<class OutputIterator, class Size, class Generator>
      void generate_n(OutputIterator first, Size n, Generator gen);
T   template<class ForwardIterator, class T>
      ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                             const T& value);
T   template<class ForwardIterator, class Predicate>
      ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                Predicate pred);
T   template<class InputIterator, class OutputIterator, class T>
      OutputIterator remove_copy(InputIterator first, InputIterator last,
                                 OutputIterator result, const T& value);
T   template<class InputIterator, class OutputIterator, class Predicate>
      OutputIterator remove_copy_if(InputIterator first, InputIterator last,
                                    OutputIterator result, Predicate pred);
T   template<class ForwardIterator>
      ForwardIterator unique(ForwardIterator first, ForwardIterator last);
T   template<class ForwardIterator, class BinaryPredicate>
      ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate pred);
T   template<class InputIterator, class OutputIterator>
      OutputIterator unique_copy(InputIterator first, InputIterator last,
                                 OutputIterator result);
T   template<class InputIterator, class OutputIterator, class BinaryPredicate>
      OutputIterator unique_copy(InputIterator first, InputIterator last,
                                 OutputIterator result, BinaryPredicate pred);
T   template<class BidirectionalIterator>
      void reverse(BidirectionalIterator first, BidirectionalIterator last);
T   template<class BidirectionalIterator, class OutputIterator>
      OutputIterator reverse_copy(BidirectionalIterator first,
                                  BidirectionalIterator last,
                                  OutputIterator result);

T   template<class ForwardIterator>
      void rotate(ForwardIterator first, ForwardIterator middle,
                  ForwardIterator last);
T   template<class ForwardIterator, class OutputIterator>
      OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle,
                                 ForwardIterator last, OutputIterator result);
T   template<class RandomAccessIterator>
      void random_shuffle(RandomAccessIterator first,
                          RandomAccessIterator last);
T   template<class RandomAccessIterator, class RandomNumberGenerator>
      void random_shuffle(RandomAccessIterator first,
                          RandomAccessIterator last,
                          RandomNumberGenerator& rand);
    // _lib.alg.partitions_, partitions:
T   template<class BidirectionalIterator, class Predicate>
      BidirectionalIterator partition(BidirectionalIterator first,
                                      BidirectionalIterator last,
                                      Predicate pred);
T   template<class BidirectionalIterator, class Predicate>
      BidirectionalIterator stable_partition(BidirectionalIterator first,
                                             BidirectionalIterator last,
                                             Predicate pred);
    // _lib.alg.sorting_, sorting and related operations:
    // _lib.alg.sort_, sorting:
T   template<class RandomAccessIterator>
      void sort(RandomAccessIterator first, RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void sort(RandomAccessIterator first, RandomAccessIterator last,
                Compare comp);
T   template<class RandomAccessIterator>
      void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
T   template<class RandomAccessIterator>
      void partial_sort(RandomAccessIterator first,
                        RandomAccessIterator middle,
                        RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void partial_sort(RandomAccessIterator first,
                        RandomAccessIterator middle,
                        RandomAccessIterator last, Compare comp);
T   template<class InputIterator, class RandomAccessIterator>
      RandomAccessIterator
        partial_sort_copy(InputIterator first, InputIterator last,
                          RandomAccessIterator result_first,
                          RandomAccessIterator result_last);
T   template<class InputIterator, class RandomAccessIterator, class Compare>
      RandomAccessIterator
        partial_sort_copy(InputIterator first, InputIterator last,
                          RandomAccessIterator result_first,
                          RandomAccessIterator result_last,
                          Compare comp);

T   template<class RandomAccessIterator>
      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                       RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                       RandomAccessIterator last, Compare comp);
    // _lib.alg.binary.search_, binary search:
T   template<class ForwardIterator, class T>
      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                  const T& value);
T   template<class ForwardIterator, class T, class Compare>
      ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                  const T& value, Compare comp);
T   template<class ForwardIterator, class T>
      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                  const T& value);
T   template<class ForwardIterator, class T, class Compare>
      ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                  const T& value, Compare comp);
T   template<class ForwardIterator, class T>
      pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T& value);
T   template<class ForwardIterator, class T, class Compare>
      pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T& value, Compare comp);
T   template<class ForwardIterator, class T>
      bool binary_search(ForwardIterator first, ForwardIterator last,
                         const T& value);
T   template<class ForwardIterator, class T, class Compare>
      bool binary_search(ForwardIterator first, ForwardIterator last,
                         const T& value, Compare comp);
    // _lib.alg.merge_, merge:
T   template<class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                           InputIterator2 first2, InputIterator2 last2,
                           OutputIterator result);
T   template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
      OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                           InputIterator2 first2, InputIterator2 last2,
                           OutputIterator result, Compare comp);
T   template<class BidirectionalIterator>
      void inplace_merge(BidirectionalIterator first,
                         BidirectionalIterator middle,
                         BidirectionalIterator last);
T   template<class BidirectionalIterator, class Compare>
      void inplace_merge(BidirectionalIterator first,
                         BidirectionalIterator middle,
                         BidirectionalIterator last, Compare comp);

    // _lib.alg.set.operations_, set operations:
T   template<class InputIterator1, class InputIterator2>
      bool includes(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2);
T   template<class InputIterator1, class InputIterator2, class Compare>
      bool includes(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, InputIterator2 last2, Compare comp);
T   template<class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, InputIterator2 last2,
                               OutputIterator result);
T   template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
      OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, InputIterator2 last2,
                               OutputIterator result, Compare comp);
T   template<class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator set_intersection
          (InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, InputIterator2 last2,
           OutputIterator result);
T   template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
      OutputIterator set_intersection
          (InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, InputIterator2 last2,
           OutputIterator result, Compare comp);
T   template<class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator set_difference
          (InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, InputIterator2 last2,
           OutputIterator result);
T   template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
      OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
                                    InputIterator2 first2, InputIterator2 last2,
                                    OutputIterator result, Compare comp);
T   template<class InputIterator1, class InputIterator2, class OutputIterator>
      OutputIterator
        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result);
T   template<class InputIterator1, class InputIterator2, class OutputIterator,
              class Compare>
      OutputIterator
        set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result, Compare comp);
    // _lib.alg.heap.operations_, heap operations:
T   template<class RandomAccessIterator>
      void push_heap(RandomAccessIterator first, RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void push_heap(RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp);

T   template<class RandomAccessIterator>
      void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                    Compare comp);
T   template<class RandomAccessIterator>
      void make_heap(RandomAccessIterator first, RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void make_heap(RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp);
T   template<class RandomAccessIterator>
      void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
T   template<class RandomAccessIterator, class Compare>
      void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp);
    // _lib.alg.min.max_, minimum and maximum:
T   template<class T> const T& min(const T& a, const T& b);
T   template<class T, class Compare>
      const T& min(const T& a, const T& b, Compare comp);
T   template<class T> const T& max(const T& a, const T& b);
T   template<class T, class Compare>
      const T& max(const T& a, const T& b, Compare comp);
T   template<class ForwardIterator>
      ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
T   template<class ForwardIterator, class Compare>
      ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                Compare comp);
T   template<class ForwardIterator>
      ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
T   template<class ForwardIterator, class Compare>
      ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                Compare comp);
T   template<class InputIterator1, class InputIterator2>
      bool lexicographical_compare
          (InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, InputIterator2 last2);
T   template<class InputIterator1, class InputIterator2, class Compare>
      bool lexicographical_compare
          (InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, InputIterator2 last2,
           Compare comp);

    // _lib.alg.permutation.generators_, permutations
T   template<class BidirectionalIterator>
      bool next_permutation(BidirectionalIterator first,
                            BidirectionalIterator last);
T   template<class BidirectionalIterator, class Compare>
      bool next_permutation(BidirectionalIterator first,
                            BidirectionalIterator last, Compare comp);
T   template<class BidirectionalIterator>
      bool prev_permutation(BidirectionalIterator first,
                            BidirectionalIterator last);
T   template<class BidirectionalIterator, class Compare>
      bool prev_permutation(BidirectionalIterator first,
                            BidirectionalIterator last, Compare comp);


   25.4  C library algorithms                         [lib.alg.c.library]

   1 Header <cstdlib> (partial, Table 2):

                    Table 2--Header <cstdlib> 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 <complex> synopsis               [lib.complex.synopsis]

T   template<class T> class complex;
T   template<> class complex<float>;
T   template<> class complex<double>;
T   template<> class complex<long double>;
    // _lib.complex.ops_ operators:
T   template<class T>
      complex<T> operator+(const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator+(const complex<T>&, const T&);
T   template<class T> complex<T> operator+(const T&, const complex<T>&);
T   template<class T> complex<T> operator-
      (const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator-(const complex<T>&, const T&);
T   template<class T> complex<T> operator-(const T&, const complex<T>&);
T   template<class T> complex<T> operator*
      (const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator*(const complex<T>&, const T&);
T   template<class T> complex<T> operator*(const T&, const complex<T>&);
T   template<class T> complex<T> operator/
      (const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator/(const complex<T>&, const T&);
T   template<class T> complex<T> operator/(const T&, const complex<T>&);
T   template<class T> complex<T> operator+(const complex<T>&);
T   template<class T> complex<T> operator-(const complex<T>&);
T   template<class T> bool operator==
      (const complex<T>&, const complex<T>&);
T   template<class T> bool operator==(const complex<T>&, const T&);
T   template<class T> bool operator==(const T&, const complex<T>&);
T   template<class T> bool operator!=(const complex<T>&, const complex<T>&);
T   template<class T> bool operator!=(const complex<T>&, const T&);
T   template<class T> bool operator!=(const T&, const complex<T>&);
T   template<class T, class charT, class traits>
      basic_istream<charT, traits>&
      operator>>(basic_istream<charT, traits>&, complex<T>&);

T   template<class T, class charT, class traits>
      basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>&, const complex<T>&);
    // _lib.complex.value.ops_ values:
T   template<class T> T real(const complex<T>&);
T   template<class T> T imag(const complex<T>&);

T   template<class T> T abs(const complex<T>&);
T   template<class T> T arg(const complex<T>&);
T   template<class T> T norm(const complex<T>&);
T   template<class T> complex<T> conj(const complex<T>&);
T   template<class T> complex<T> polar(const T&, const T&);
    // _lib.complex.transcendentals_ transcendentals:
T   template<class T> complex<T> cos  (const complex<T>&);
T   template<class T> complex<T> cosh (const complex<T>&);
T   template<class T> complex<T> exp  (const complex<T>&);
T   template<class T> complex<T> log  (const complex<T>&);
T   template<class T> complex<T> log10(const complex<T>&);
T   template<class T> complex<T> pow(const complex<T>&, int);
T   template<class T> complex<T> pow(const complex<T>&, const T&);
T   template<class T> complex<T> pow(const complex<T>&, const complex<T>&);
T   template<class T> complex<T> pow(const T&, const complex<T>&);
T   template<class T> complex<T> sin  (const complex<T>&);
T   template<class T> complex<T> sinh (const complex<T>&);
T   template<class T> complex<T> sqrt (const complex<T>&);
T   template<class T> complex<T> tan  (const complex<T>&);
T   template<class T> complex<T> tanh (const complex<T>&);
   }

   26.2.2  Template class complex                           [lib.complex]

    template<class T>
T   class complex {
    public:
T     typedef T value_type;

T     complex(const T& re = T(), const T& im = T());
T     complex(const complex&);
T     template<class X> complex(const complex<X>&);

T     T real() const;
T     T imag() const;

T     complex<T>& operator= (const T&);
T     complex<T>& operator+=(const T&);
T     complex<T>& operator-=(const T&);
T     complex<T>& operator*=(const T&);
T     complex<T>& operator/=(const T&);

T     complex& operator=(const complex&);
T     template<class X> complex<T>& operator= (const complex<X>&);
T     template<class X> complex<T>& operator+=(const complex<X>&);
T     template<class X> complex<T>& operator-=(const complex<X>&);
T     template<class X> complex<T>& operator*=(const complex<X>&);
T     template<class X> complex<T>& operator/=(const complex<X>&);
    };

T   template<class T> complex<T> operator+
      (const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator+(const complex<T>&, const T&);
T   template<class T> complex<T> operator+(const T&, const complex<T>&);

T   template<class T> complex<T> operator-
      (const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator-(const complex<T>&, const T&);
T   template<class T> complex<T> operator-(const T&, const complex<T>&);

T   template<class T> complex<T> operator*
      (const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator*(const complex<T>&, const T&);
T   template<class T> complex<T> operator*(const T&, const complex<T>&);

T   template<class T> complex<T> operator/
      (const complex<T>&, const complex<T>&);
T   template<class T> complex<T> operator/(const complex<T>&, const T&);
T   template<class T> complex<T> operator/(const T&, const complex<T>&);

T   template<class T> complex<T> operator+(const complex<T>&);
T   template<class T> complex<T> operator-(const complex<T>&);

T   template<class T> bool operator==(const complex<T>&, const complex<T>&);
T   template<class T> bool operator==(const complex<T>&, const T&);
T   template<class T> bool operator==(const T&, const complex<T>&);

T   template<class T> bool operator!=(const complex<T>&, const complex<T>&);
T   template<class T> bool operator!=(const complex<T>&, const T&);
T   template<class T> bool operator!=(const T&, const complex<T>&);

T   template<class T, class charT, class traits>
      basic_istream<charT, traits>&
      operator>>(basic_istream<charT, traits>&, complex<T>&);

T   template<class T, class charT, class traits>
      basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>&, const complex<T>&);


   26.2.3  complex specializations                  [lib.complex.special]

T   template<> class complex<float> {
    public:
T     typedef float value_type;

T     complex(float re = 0.0f, float im = 0.0f);
T     explicit complex(const complex<double>&);
T     explicit complex(const complex<long double>&);
T     float real() const;
T     float imag() const;

T     complex<float>& operator= (float);
T     complex<float>& operator+=(float);
T     complex<float>& operator-=(float);
T     complex<float>& operator*=(float);
T     complex<float>& operator/=(float);

T     complex<float>& operator=(const complex<float>&);
T     template<class X> complex<float>& operator= (const complex<X>&);
T     template<class X> complex<float>& operator+=(const complex<X>&);
T     template<class X> complex<float>& operator-=(const complex<X>&);
T     template<class X> complex<float>& operator*=(const complex<X>&);
T     template<class X> complex<float>& operator/=(const complex<X>&);
    };
T   template<> class complex<double> {
    public:
T     typedef double value_type;

T     complex(double re = 0.0, double im = 0.0);
T     complex(const complex<float>&);
T     explicit complex(const complex<long double>&);
T     double real() const;
T     double imag() const;

T     complex<double>& operator= (double);
T     complex<double>& operator+=(double);
T     complex<double>& operator-=(double);
T     complex<double>& operator*=(double);
T     complex<double>& operator/=(double);

T     complex<double>& operator=(const complex<double>&);
T     template<class X> complex<double>& operator= (const complex<X>&);
T     template<class X> complex<double>& operator+=(const complex<X>&);
T     template<class X> complex<double>& operator-=(const complex<X>&);
T     template<class X> complex<double>& operator*=(const complex<X>&);
T     template<class X> complex<double>& operator/=(const complex<X>&);
    };

T   template<> class complex<long double> {
    public:
T     typedef long double value_type;

T     complex(long double re = 0.0L, long double im = 0.0L);
T     complex(const complex<float>&);
T     complex(const complex<double>&);
T     long double real() const;
T     long double imag() const;

T     complex<long double>& operator=(const complex<long double>&);
T     complex<long double>& operator= (long double);
T     complex<long double>& operator+=(long double);
T     complex<long double>& operator-=(long double);
T     complex<long double>& operator*=(long double);
T     complex<long double>& operator/=(long double);

T     template<class X> complex<long double>& operator= (const complex<X>&);
T     template<class X> complex<long double>& operator+=(const complex<X>&);
T     template<class X> complex<long double>& operator-=(const complex<X>&);
T     template<class X> complex<long double>& operator*=(const complex<X>&);
T     template<class X> complex<long double>& operator/=(const complex<X>&);
    };

   26.3  Numeric arrays                                    [lib.numarray]

   26.3.1  Header <valarray> synopsis             [lib.valarray.synopsis]

T   template<class T> class valarray;         // An array of type T
T   class slice;
T   template<class T> class slice_array;
T   class gslice;
T   template<class T> class gslice_array;
T   template<class T> class mask_array;       // a masked array
T   template<class T> class indirect_array;   // an indirected array

T   template<class T> valarray<T> operator*
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator* (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator* (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator/
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator/ (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator/ (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator%
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator% (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator% (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator+
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator+ (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator+ (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator-
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator- (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator- (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator^
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator^ (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator^ (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator&
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator& (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator& (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator|
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator| (const valarray<T>&, const T&);
T   template<class T> valarray<T> operator| (const T&, const valarray<T>&);
T   template<class T> valarray<T> operator<<
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator<<(const valarray<T>&, const T&);
T   template<class T> valarray<T> operator<<(const T&, const valarray<T>&);
T   template<class T> valarray<T> operator>>
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> operator>>(const valarray<T>&, const T&);
T   template<class T> valarray<T> operator>>(const T&, const valarray<T>&);
T   template<class T> valarray<bool> operator&&
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator&&(const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator&&(const T&, const valarray<T>&);
T   template<class T> valarray<bool> operator||
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator||(const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator||(const T&, const valarray<T>&);

T   template<class T>
      valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator==(const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator==(const T&, const valarray<T>&);
T   template<class T>
      valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator!=(const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator!=(const T&, const valarray<T>&);
T   template<class T>
      valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator< (const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator< (const T&, const valarray<T>&);
T   template<class T>
      valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator> (const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator> (const T&, const valarray<T>&);
T   template<class T>
      valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator<=(const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator<=(const T&, const valarray<T>&);
T   template<class T>
      valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<bool> operator>=(const valarray<T>&, const T&);
T   template<class T> valarray<bool> operator>=(const T&, const valarray<T>&);
T   template<class T> valarray<T> abs  (const valarray<T>&);
T   template<class T> valarray<T> acos (const valarray<T>&);
T   template<class T> valarray<T> asin (const valarray<T>&);
T   template<class T> valarray<T> atan (const valarray<T>&);
T   template<class T> valarray<T> atan2
      (const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> atan2(const valarray<T>&, const T&);
T   template<class T> valarray<T> atan2(const T&, const valarray<T>&);
T   template<class T> valarray<T> cos  (const valarray<T>&);
T   template<class T> valarray<T> cosh (const valarray<T>&);
T   template<class T> valarray<T> exp  (const valarray<T>&);
T   template<class T> valarray<T> log  (const valarray<T>&);
T   template<class T> valarray<T> log10(const valarray<T>&);
T   template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
T   template<class T> valarray<T> pow(const valarray<T>&, const T&);
T   template<class T> valarray<T> pow(const T&, const valarray<T>&);
T   template<class T> valarray<T> sin  (const valarray<T>&);
T   template<class T> valarray<T> sinh (const valarray<T>&);
T   template<class T> valarray<T> sqrt (const valarray<T>&);
T   template<class T> valarray<T> tan  (const valarray<T>&);
T   template<class T> valarray<T> tanh (const valarray<T>&);
   }


   26.3.2  Template class valarray                [lib.template.valarray]

T   template<class T> class valarray {
    public:
T     typedef T value_type;

      // _lib.valarray.cons_ construct/destroy:
T     valarray();
T     explicit valarray(size_t);
T     valarray(const T&, size_t);
T     valarray(const T*, size_t);
T     valarray(const valarray&);
T     valarray(const slice_array<T>&);
T     valarray(const gslice_array<T>&);
T     valarray(const mask_array<T>&);
T     valarray(const indirect_array<T>&);
T    ~valarray();

      // _lib.valarray.assign_ assignment:
T     valarray<T>& operator=(const valarray<T>&);
T     valarray<T>& operator=(const T&);
T     valarray<T>& operator=(const slice_array<T>&);
T     valarray<T>& operator=(const gslice_array<T>&);
T     valarray<T>& operator=(const mask_array<T>&);
T     valarray<T>& operator=(const indirect_array<T>&);
      // _lib.valarray.access_ element access:
T     T                 operator[](size_t) const;
T     T&                operator[](size_t);
      // _lib.valarray.sub_ subset operations:
T     valarray<T>       operator[](slice) const;
T     slice_array<T>    operator[](slice);
T     valarray<T>       operator[](const gslice&) const;
T     gslice_array<T>   operator[](const gslice&);
T     valarray<T>       operator[](const valarray<bool>&) const;
T     mask_array<T>     operator[](const valarray<bool>&);
T     valarray<T>       operator[](const valarray<size_t>&) const;
T     indirect_array<T> operator[](const valarray<size_t>&);
      // _lib.valarray.unary_ unary operators:
T     valarray<T> operator+() const;
T     valarray<T> operator-() const;
T     valarray<T> operator~() const;
T     valarray<T> operator!() const;
      // _lib.valarray.cassign_ computed assignment:
T     valarray<T>& operator*= (const T&);
T     valarray<T>& operator/= (const T&);
T     valarray<T>& operator%= (const T&);
T     valarray<T>& operator+= (const T&);
T     valarray<T>& operator-= (const T&);
T     valarray<T>& operator^= (const T&);
T     valarray<T>& operator&= (const T&);
T     valarray<T>& operator|= (const T&);
T     valarray<T>& operator<<=(const T&);
T     valarray<T>& operator>>=(const T&);
T     valarray<T>& operator*= (const valarray<T>&);
T     valarray<T>& operator/= (const valarray<T>&);
T     valarray<T>& operator%= (const valarray<T>&);
T     valarray<T>& operator+= (const valarray<T>&);
T     valarray<T>& operator-= (const valarray<T>&);
T     valarray<T>& operator^= (const valarray<T>&);
T     valarray<T>& operator|= (const valarray<T>&);
T     valarray<T>& operator&= (const valarray<T>&);
T     valarray<T>& operator<<=(const valarray<T>&);
T     valarray<T>& operator>>=(const valarray<T>&);
      // _lib.valarray.members_ member functions:
T     size_t size() const;
T     T    sum() const;
T     T    min() const;
T     T    max() const;

T     valarray<T> shift (int) const;
T     valarray<T> cshift(int) const;
T     valarray<T> apply(T func(T)) const;
T     valarray<T> apply(T func(const T&)) 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 <class T> class slice_array {
    public:
T     typedef T value_type;

T     void operator=  (const valarray<T>&) const;
T     void operator*= (const valarray<T>&) const;
T     void operator/= (const valarray<T>&) const;
T     void operator%= (const valarray<T>&) const;
T     void operator+= (const valarray<T>&) const;
T     void operator-= (const valarray<T>&) const;
T     void operator^= (const valarray<T>&) const;
T     void operator&= (const valarray<T>&) const;
T     void operator|= (const valarray<T>&) const;
T     void operator<<=(const valarray<T>&) const;
T     void operator>>=(const valarray<T>&) const;
T     void operator=(const T&);
T    ~slice_array();
    private:
T     slice_array();
T     slice_array(const slice_array&);
T     slice_array& operator=(const slice_array&);
    };
   }



   26.3.6  The gslice class                            [lib.class.gslice]

T   class gslice {
    public:
T     gslice();
T     gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d);

T     size_t           start() const;
T     valarray<size_t> size() const;
T     valarray<size_t> stride() const;
    };


   26.3.7  Template class gslice_array        [lib.template.gslice.array]

T   template <class T> class gslice_array {
    public:
T     typedef T value_type;

T     void operator=  (const valarray<T>&) const;
T     void operator*= (const valarray<T>&) const;
T     void operator/= (const valarray<T>&) const;
T     void operator%= (const valarray<T>&) const;
T     void operator+= (const valarray<T>&) const;
T     void operator-= (const valarray<T>&) const;
T     void operator^= (const valarray<T>&) const;
T     void operator&= (const valarray<T>&) const;
T     void operator|= (const valarray<T>&) const;
T     void operator<<=(const valarray<T>&) const;
T     void operator>>=(const valarray<T>&) const;
T     void operator=(const T&);
T    ~gslice_array();
    private:
T     gslice_array();
T     gslice_array(const gslice_array&);
T     gslice_array& operator=(const gslice_array&);
    };


   26.3.8  Template class mask_array            [lib.template.mask.array]

T   template <class T> class mask_array {
    public:
T     typedef T value_type;

T     void operator=  (const valarray<T>&) const;
T     void operator*= (const valarray<T>&) const;
T     void operator/= (const valarray<T>&) const;
T     void operator%= (const valarray<T>&) const;
T     void operator+= (const valarray<T>&) const;
T     void operator-= (const valarray<T>&) const;
T     void operator^= (const valarray<T>&) const;
T     void operator&= (const valarray<T>&) const;
T     void operator|= (const valarray<T>&) const;
T     void operator<<=(const valarray<T>&) const;
T     void operator>>=(const valarray<T>&) const;
T     void operator=(const T&);
T    ~mask_array();
    private:
T     mask_array();
T     mask_array(const mask_array&);
T     mask_array& operator=(const mask_array&);
      //  remainder implementation defined
    };


   26.3.9  Template class                   [lib.template.indirect.array]
       indirect_array

T   template <class T> class indirect_array {
    public:
T     typedef T value_type;

T     void operator=  (const valarray<T>&) const;
T     void operator*= (const valarray<T>&) const;
T     void operator/= (const valarray<T>&) const;
T     void operator%= (const valarray<T>&) const;
T     void operator+= (const valarray<T>&) const;
T     void operator-= (const valarray<T>&) const;
T     void operator^= (const valarray<T>&) const;
T     void operator&= (const valarray<T>&) const;
T     void operator|= (const valarray<T>&) const;
T     void operator<<=(const valarray<T>&) const;
T     void operator>>=(const valarray<T>&) const;
T     void operator=(const T&);
T    ~indirect_array();
    private:
T     indirect_array();
T     indirect_array(const indirect_array&);
T     indirect_array& operator=(const indirect_array&);
      //  remainder implementation defined
    };

   26.4  Generalized numeric operations                 [lib.numeric.ops]

   Header <numeric> synopsis

T   template <class InputIterator, class T>
      T accumulate(InputIterator first, InputIterator last, T init);

T   template <class InputIterator, class T, class BinaryOperation>
      T accumulate(InputIterator first, InputIterator last, T init,
                   BinaryOperation binary_op);

T   template <class InputIterator1, class InputIterator2, class T>
      T inner_product(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, T init);

T   template <class InputIterator1, class InputIterator2, class T,
              class BinaryOperation1, class BinaryOperation2>
      T inner_product(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, T init,
                      BinaryOperation1 binary_op1,
                      BinaryOperation2 binary_op2);

T   template <class InputIterator, class OutputIterator>
      OutputIterator partial_sum(InputIterator first,
                                 InputIterator last,
                                 OutputIterator result);

T   template <class InputIterator, class OutputIterator,
              class BinaryOperation>
      OutputIterator partial_sum(InputIterator first,
                                 InputIterator last,
                                 OutputIterator result,
                                 BinaryOperation binary_op);

T   template <class InputIterator, class OutputIterator>
      OutputIterator adjacent_difference(InputIterator first,
                                         InputIterator last,
                                         OutputIterator result);

T   template <class InputIterator, class OutputIterator,
              class BinaryOperation>
      OutputIterator adjacent_difference(InputIterator first,
                                         InputIterator last,
                                         OutputIterator result,
                                         BinaryOperation binary_op);


   26.5  C Library                                           [lib.c.math]

                     Table 2--Header <cmath> 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 <cstdlib> 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 <iosfwd> synopsis

X   template<class charT> class char_traits;
X   template<> class char_traits<char>;
X   template<> class char_traits<wchar_t>;
X   template<class T> class allocator;
X   template <class charT, class traits = char_traits<charT> >
      class basic_ios;

X   template <class charT, class traits = char_traits<charT> >
      class basic_streambuf;

X   template <class charT, class traits = char_traits<charT> >
      class basic_istream;

X   template <class charT, class traits = char_traits<charT> >
      class basic_ostream;

X   template <class charT, class traits = char_traits<charT> >
      class basic_iostream;

X   template <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
      class basic_stringbuf;

X   template <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
      class basic_istringstream;

X   template <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
      class basic_ostringstream;

X   template <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
      class basic_stringstream;

X   template <class charT, class traits = char_traits<charT> >
      class basic_filebuf;

X   template <class charT, class traits = char_traits<charT> >
      class basic_ifstream;

X   template <class charT, class traits = char_traits<charT> >
      class basic_ofstream;

X   template <class charT, class traits = char_traits<charT> >
      class basic_fstream;
X   template <class charT, class traits = char_traits<charT> >
      class istreambuf_iterator;

X   template <class charT, class traits = char_traits<charT> >
      class ostreambuf_iterator;
X   typedef basic_ios<char>       ios;
X   typedef basic_ios<wchar_t>    wios;
X   typedef basic_streambuf<char> streambuf;
X   typedef basic_istream<char>   istream;
X   typedef basic_ostream<char>   ostream;
X   typedef basic_iostream<char>  iostream;
X   typedef basic_stringbuf<char>     stringbuf;
X   typedef basic_istringstream<char> istringstream;
X   typedef basic_ostringstream<char> ostringstream;
X   typedef basic_stringstream<char>  stringstream;
X   typedef basic_filebuf<char>  filebuf;
X   typedef basic_ifstream<char> ifstream;
X   typedef basic_ofstream<char> ofstream;
X   typedef basic_fstream<char>  fstream;
X   typedef basic_streambuf<wchar_t> wstreambuf;
X   typedef basic_istream<wchar_t>   wistream;
X   typedef basic_ostream<wchar_t>   wostream;
X   typedef basic_iostream<wchar_t>  wiostream;
X   typedef basic_stringbuf<wchar_t>     wstringbuf;
X   typedef basic_istringstream<wchar_t> wistringstream;
X   typedef basic_ostringstream<wchar_t> wostringstream;
X   typedef basic_stringstream<wchar_t>  wstringstream;

X   typedef basic_filebuf<wchar_t>  wfilebuf;
X   typedef basic_ifstream<wchar_t> wifstream;
X   typedef basic_ofstream<wchar_t> wofstream;
X   typedef basic_fstream<wchar_t>  wfstream;
X   template <class state> class fpos;
X   typedef fpos<char_traits<char>::state_type>    streampos;
X   typedef fpos<char_traits<wchar_t>::state_type> wstreampos;

   27.3  Standard iostream objects                 [lib.iostream.objects]

   Header <iostream> synopsis

T  [must also include <istream> and <ostream>]
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 <ios> synopsis

   #include <iosfwd>

T   typedef OFF_T  streamoff;
T   typedef SZ_T streamsize;
T   template <class stateT> class fpos;

    class ios_base;
    template <class charT, class traits = char_traits<charT> >
      class basic_ios;
   // _lib.std.ios.manip_, manipulators:
T   ios_base& boolalpha  (ios_base& str);
T   ios_base& noboolalpha(ios_base& str);
T   ios_base& showbase   (ios_base& str);
T   ios_base& noshowbase (ios_base& str);
T   ios_base& showpoint  (ios_base& str);
T   ios_base& noshowpoint(ios_base& str);
T   ios_base& showpos    (ios_base& str);
T   ios_base& noshowpos  (ios_base& str);
T   ios_base& skipws     (ios_base& str);
T   ios_base& noskipws   (ios_base& str);
T   ios_base& nouppercase(ios_base& str);
T   ios_base& uppercase  (ios_base& str);
M   ios_base& unitbuf    (ios_base& str);
M   ios_base& nounitbuf  (ios_base& str);
   // _lib.adjustfield.manip_ adjustfield:
T   ios_base& internal   (ios_base& str);
T   ios_base& left       (ios_base& str);
T   ios_base& right      (ios_base& str);
   // _lib.basefield.manip_ basefield:
T   ios_base& dec        (ios_base& str);
T   ios_base& hex        (ios_base& str);
T   ios_base& oct        (ios_base& str);

   // _lib.floatfield.manip_ floatfield:
T   ios_base& fixed      (ios_base& str);
T   ios_base& scientific (ios_base& 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& loc);
T     locale getloc() const;
      // _lib.ios.base.storage_ storage:
T     static int xalloc();
T     long&  iword(int index);
T     void*& 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&, 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& 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 <class stateT> 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 <class charT, class traits = char_traits<charT> >
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<charT,traits>* sb);
T     virtual ~basic_ios();
      // _lib.basic.ios.members_ Members:
T     basic_ostream<charT,traits>* tie() const;
T     basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);
T     basic_streambuf<charT,traits>* rdbuf() const;
T     basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
X     basic_ios& copyfmt(const basic_ios& rhs);
T     char_type fill() const;
T     char_type fill(char_type ch);
      // _lib.ios.base.locales_ locales:
T     locale imbue(const locale& 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<charT,traits>* sb);
   private:
T     basic_ios(const basic_ios& );       // not defined
T     basic_ios& operator=(const basic_ios&);     // not defined
    };


   27.5  Stream buffers                              [lib.stream.buffers]

   Header <streambuf> synopsis

X   template <class charT, class traits = char_traits<charT> >
      class basic_streambuf;
T   typedef basic_streambuf<char>     streambuf;
T   typedef basic_streambuf<wchar_t> wstreambuf;

   27.5.2  Template class                                 [lib.streambuf]
       basic_streambuf<charT,traits>

    template <class charT, class traits = char_traits<charT> >
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 &loc);
T     locale   getloc() const;
      // _lib.streambuf.buffer_ buffer and positioning:
T     basic_streambuf<char_type,traits>*
               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 &loc);
      // _lib.streambuf.virt.buffer_ Buffer management and positioning:
T     virtual basic_streambuf<char_type,traits>*
                       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 <istream> synopsis

T   template <class charT, class traits = char_traits<charT> >
      class basic_istream;
T   typedef basic_istream<char>     istream;
T   typedef basic_istream<wchar_t> wistream;

T   template <class charT, class traits = char_traits<charT> >
      class basic_iostream;
T   typedef basic_iostream<char>    iostream;
T   typedef basic_iostream<wchar_t> wiostream;

X   template <class charT, class traits>
      basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);

   Header <ostream> synopsis

X   template <class charT, class traits = char_traits<charT> >
      class basic_ostream;
T   typedef basic_ostream<char>     ostream;
T   typedef basic_ostream<wchar_t> wostream;

T   template <class charT, class traits>
      basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
T   template <class charT, class traits>
      basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
T   template <class charT, class traits>
      basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);

   Header <iomanip> 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<charT> 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 <class charT, class traits = char_traits<charT> >
T   class basic_istream : virtual public basic_ios<charT,traits> {
    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<charT,traits>* sb);
T     virtual ~basic_istream();
      // _lib.istream::sentry_ Prefix/suffix:
T     class sentry;

      // _lib.istream.formatted_ Formatted input:
T     basic_istream<charT,traits>& operator>>
          (basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
T     basic_istream<charT,traits>& operator>>
          (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
T     basic_istream<charT,traits>& operator>>
          (ios_base& (*pf)(ios_base&))
S     basic_istream<charT,traits>& operator>>(bool& n);
S     basic_istream<charT,traits>& operator>>(short& n);
S     basic_istream<charT,traits>& operator>>(unsigned short& n);
S     basic_istream<charT,traits>& operator>>(int& n);
S     basic_istream<charT,traits>& operator>>(unsigned int& n);
S     basic_istream<charT,traits>& operator>>(long& n);
S     basic_istream<charT,traits>& operator>>(unsigned long& n);
S     basic_istream<charT,traits>& operator>>(float& f);
S     basic_istream<charT,traits>& operator>>(double& f);
S     basic_istream<charT,traits>& operator>>(long double& f);
S     basic_istream<charT,traits>& operator>>(void*& p);
S     basic_istream<charT,traits>& operator>>
          (basic_streambuf<char_type,traits>* sb);
      // _lib.istream.unformatted_ Unformatted input:
T     streamsize gcount() const;
S     int_type get();
S     basic_istream<charT,traits>& get(char_type& c);
S     basic_istream<charT,traits>& get(char_type* s, streamsize n);
S     basic_istream<charT,traits>& get(char_type* s, streamsize n,
                        char_type delim);
S     basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb);
S     basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
                        char_type delim);
S     basic_istream<charT,traits>& getline(char_type* s, streamsize n);
S     basic_istream<charT,traits>& getline(char_type* s, streamsize n,
                        char_type delim);
S     basic_istream<charT,traits>& ignore
          (streamsize n = 1, int_type delim = traits::eof());
S     int_type                     peek();
S     basic_istream<charT,traits>& read    (char_type* s, streamsize n);
S     streamsize                   readsome(char_type* s, streamsize n);
S     basic_istream<charT,traits>& putback(char_type c);
S     basic_istream<charT,traits>& unget();
S     int sync();

S     pos_type tellg();
S     basic_istream<charT,traits>& seekg(pos_type);
S     basic_istream<charT,traits>& seekg(off_type, ios_base::seekdir);
    };

    // _lib.istream::extractors_ character extraction templates:
S   template<class charT, class traits>
      basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
                                              charT&);
S   template<class traits>
      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
                                             unsigned char&);
S   template<class traits>
      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
                                             signed char&);

S   template<class charT, class traits>
      basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&,
                                              charT*);
S   template<class traits>
      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
                                             unsigned char*);
S   template<class traits>
      basic_istream<char,traits>& operator>>(basic_istream<char,traits>&,
                                             signed char*);

   27.6.1.1.2  Class basic_istream::sentry          [lib.istream::sentry]


    template <class charT,class traits = char_traits<charT> >
S   class basic_istream<charT,traits>::sentry {
      typedef traits traits_type;
S     bool ok_; // exposition only
     public:
S     explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
S     ~sentry();
S     operator bool() const { return ok_; }
     private:
T     sentry(const sentry&); //   not defined
T     sentry& operator=(const sentry&); //   not defined
    };


   27.6.1.5  Template class basic_iostream            [lib.iostreamclass]

    template <class charT, class traits = char_traits<charT> >
T   class basic_iostream :
      public basic_istream<charT,traits>,
      public basic_ostream<charT,traits> {
    public:
      // constructor/destructor
T     explicit basic_iostream(basic_streambuf<charT,traits>* sb);
T     virtual ~basic_iostream();
    };


   27.6.2.1  Template class basic_ostream                   [lib.ostream]

    template <class charT, class traits = char_traits<charT> >
X   class basic_ostream : virtual public basic_ios<charT,traits> {
    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<char_type,traits>* sb);
T     virtual ~basic_ostream();
      // _lib.ostream::sentry_ Prefix/suffix:
T     class sentry;
      // _lib.ostream.formatted_ Formatted output:
T     basic_ostream<charT,traits>& operator<<
          (basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&));
T     basic_ostream<charT,traits>& operator<<
          (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
T     basic_ostream<charT,traits>& operator<<
          (ios_base& (*pf)(ios_base&));
T     basic_ostream<charT,traits>& operator<<(bool n);
T     basic_ostream<charT,traits>& operator<<(short n);
T     basic_ostream<charT,traits>& operator<<(unsigned short n);
T     basic_ostream<charT,traits>& operator<<(int n);
T     basic_ostream<charT,traits>& operator<<(unsigned int n);
T     basic_ostream<charT,traits>& operator<<(long n);
T     basic_ostream<charT,traits>& operator<<(unsigned long n);
S     basic_ostream<charT,traits>& operator<<(float f);
S     basic_ostream<charT,traits>& operator<<(double f);
S     basic_ostream<charT,traits>& operator<<(long double f);
T     basic_ostream<charT,traits>& operator<<(const void* p);
X     basic_ostream<charT,traits>& operator<<
          (basic_streambuf<char_type,traits>* sb);
      // _lib.ostream.unformatted_ Unformatted output:
T     basic_ostream<charT,traits>& put(char_type c);
T     basic_ostream<charT,traits>& write(const char_type* s, streamsize n);
X     basic_ostream<charT,traits>& flush();

      // _lib.ostream.seeks_ seeks:
S     pos_type tellp();
S     basic_ostream<charT,traits>& seekp(pos_type);
S     basic_ostream<charT,traits>& seekp(off_type, ios_base::seekdir);
    };
    // _lib.ostream.inserters.character_ character inserters
X   template<class charT, class traits>
    basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
                                            charT);
X   template<class charT, class traits>
    basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
                                            char);
    // specialization
X   template<class traits>
      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
                                             char);
    // signed and unsigned
X   template<class traits>
      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
                                             signed char);
X   template<class traits>
      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
                                             unsigned char)
X   template<class charT, class traits>
      basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
                                              const charT*);
X   template<class charT, class traits>
      basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
                                              const char*);
    // partial specializationss
X   template<class traits>
      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
                                             const char*);
    //  signed and unsigned
X   template<class traits>
      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
                                             const signed char*);
X   template<class traits>
      basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
                                             const unsigned char*);


   27.6.2.3  Class basic_ostream::sentry            [lib.ostream::sentry]

    template <class charT,class traits = char_traits<charT> >
X   class basic_ostream<charT,traits>::sentry {
      bool ok_; // exposition only
     public:
X     explicit sentry(basic_ostream<charT,traits>& os);
X     ~sentry();
X     operator bool() const { return ok_; }
     private
X     sentry(const sentry&); //   not defined
X     sentry& operator=(const sentry&); //   not defined
    };

   27.7  String-based streams                        [lib.string.streams]

   Header <sstream> synopsis

X   template <class charT, class traits = char_traits<charT>,
                      class Allocator = allocator<charT> >
      class basic_stringbuf;

T   typedef basic_stringbuf<char>     stringbuf;
T   typedef basic_stringbuf<wchar_t> wstringbuf;

    template <class charT, class traits = char_traits<charT>,
                      class Allocator = allocator<charT> >
X     class basic_istringstream;

T   typedef basic_istringstream<char>     istringstream;
T   typedef basic_istringstream<wchar_t> wistringstream;

    template <class charT, class traits = char_traits<charT>,
                      class Allocator = allocator<charT> >
X     class basic_ostringstream;
T   typedef basic_ostringstream<char>     ostringstream;
T   typedef basic_ostringstream<wchar_t> wostringstream;

    template <class charT, class traits = char_traits<charT>,
                      class Allocator = allocator<charT> >
X     class basic_stringstream;
T   typedef basic_stringstream<char>     stringstream;
T   typedef basic_stringstream<wchar_t> wstringstream;

   27.7.1  Template class basic_stringbuf                 [lib.stringbuf]

    template <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
X   class basic_stringbuf : public basic_streambuf<charT,traits> {
    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<charT,traits,Allocator>& str,
           ios_base::openmode which = ios_base::in | ios_base::out);
      // _lib.stringbuf.members_ Get and set:
S     basic_string<charT,traits,Allocator> str() const;
S     void               str(const basic_string<charT,traits,Allocator>& 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<charT,traits>* 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 <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
X   class basic_istringstream : public basic_istream<charT,traits> {
    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<charT,traits,Allocator>& str,
                         ios_base::openmode which = ios_base::in);

      // _lib.istringstream.members_ Members:
S     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
S     basic_string<charT,traits,Allocator> str() const;
S     void str(const basic_string<charT,traits,Allocator>& s);
   private:
   //  basic_stringbuf<charT,traits,Allocator> sb;   exposition only
    };

   27.7.3  Class basic_ostringstream                  [lib.ostringstream]

    template <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
X   class basic_ostringstream : public basic_ostream<charT,traits> {
    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<charT,traits,Allocator>& str,
                           ios_base::openmode which = ios_base::out);
      // _lib.ostringstream.members_ Members:
S     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
S     basic_string<charT,traits,Allocator> str() const;
S     void    str(const basic_string<charT,traits,Allocator>& s);
    };


   27.7.4  Template class basic_stringstream           [lib.stringstream]

    template <class charT, class traits = char_traits<charT>,
              class Allocator = allocator<charT> >
X   class basic_stringstream
      : public basic_iostream<charT,traits> {
    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<charT,traits,Allocator>& str,
          ios_base::openmode which = ios_base::out|ios_base::in);
      // Members:
S     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
S     basic_string<charT,traits,Allocator> str() const;
S     void str(const basic_string<charT,traits,Allocator>& str);
    };



   27.8.1  File streams                                    [lib.fstreams]


   Header <fstream> synopsis

X   template <class charT, class traits = char_traits<charT> >
      class basic_filebuf;
T   typedef basic_filebuf<char>    filebuf;
T   typedef basic_filebuf<wchar_t> wfilebuf;

X   template <class charT, class traits = char_traits<charT> >
      class basic_ifstream;
T   typedef basic_ifstream<char>    ifstream;
T   typedef basic_ifstream<wchar_t> wifstream;

X   template <class charT, class traits = char_traits<charT> >
      class basic_ofstream;
T   typedef basic_ofstream<char>    ofstream;
T   typedef basic_ofstream<wchar_t> wofstream;

X   template <class charT, class traits = char_traits<charT> >
      class basic_fstream;
T   typedef basic_fstream<char>     fstream;
T   typedef basic_fstream<wchar_t> wfstream;

   27.8.1.1  Template class basic_filebuf                   [lib.filebuf]

    template <class charT, class traits = char_traits<charT> >
X   class basic_filebuf : public basic_streambuf<charT,traits> {
    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<charT,traits>* open
          (const char* s, ios_base::openmode mode);
X     basic_filebuf<charT,traits>* 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<charT,traits>*
                       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& loc);
    };



   27.8.1.5  Template class basic_ifstream                 [lib.ifstream]

    template <class charT, class traits = char_traits<charT> >
X   class basic_ifstream : public basic_istream<charT,traits> {
    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<charT,traits>* 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 <class charT, class traits = char_traits<charT> >
X   class basic_ofstream : public basic_ostream<charT,traits> {
    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<charT,traits>* 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 <class charT, class traits=char_traits<charT> >
X   class basic_fstream
      : public basic_iostream<charT,traits> {
    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<charT,traits>* 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 <cstdio> synopsis
    Macros:
X   BUFSIZ         L_tmpnam        SEEK_SET   TMP_MAX
X   EOF            NULL <cstdio>   stderr     _IOFBF
X   FILENAME_MAX   SEEK_CUR        stdin      _IOLBF
X   FOPEN_MAX      SEEK_END        stdout     _IONBF

X   Types:         FILE            fpos_t     size_t <cstdio>
    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     <assert.h>   <iso646.h>   <setjmp.h>   <stdio.h>    <wchar.h>
      <ctype.h>    <limits.h>   <signal.h>   <stdlib.h>   <wctype.h>
      <errno.h>    <locale.h>   <stdarg.h>   <string.h>
      <float.h>    <math.h>     <stddef.h>   <time.h>

   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<class charT, class traits = char_traits<charT> >
    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<class charT, class Traits> 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<class charT, class traits = char_traits<charT> >
    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 <class charT, class traits = char_traits<charT> >
    class basic_filebuf : public basic_streambuf<charT,traits> {
    public:
M     basic_filebuf<charT,traits>* open
          (const char* s, ios_base::open_mode mode);
      // remainder unchanged
    };
    template <class charT, class traits = char_traits<charT> >
    class basic_ifstream : public basic_istream<charT,traits> {
    public:
M     void open(const char* s, ios_base::open_mode mode = in);
      // remainder unchanged
    };
    template <class charT, class traits = char_traits<charT> >
    class basic_ofstream : public basic_ostream<charT,traits> {
    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<char> {
    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<char>* setbuf(char* s, streamsize n);
   }

   1.7.4  Class strstream                                [depr.strstream]

M   class strstream
      : public basic_iostream<char> {
    public:
      // Types
M     typedef char                                char_type;
M     typedef typename char_traits<char>::int_type int_type
M     typedef typename char_traits<char>::pos_type pos_type;
M     typedef typename char_traits<char>::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();
    };

