namespace std { // C++ standard library
 namespace tr1 { // TR1 additions

    // CLASS TEMPLATE regex_traits AND basic_regex
template <class Elem>
  struct regex_traits ;
template <>
  struct regex_traits <char>;
template <>
  struct regex_traits <wchar_t>;
template <class Elem,
  class RXtraits = regex_traits <Elem>,
  class basic_regex;
typedef basic_regex <char> regex;
typedef basic_regex <wchar_t> wregex ;

    // CLASS TEMPLATE sub_match
template <class BidIt>
  class sub_match ;
typedef sub_match <const char*> csub_match;
typedef sub_match <const wchar_t *> wcsub_match;
typedef sub_match <string :: const_iterator> ssub_match;
typedef sub_match <wstring :: const_iterator> wssub_match;


    // CLASS TEMPLATE match_results
template <class BidIt,
  class Alloc = allocator <
    typename iterator_traits <BidIt>:: value_type> >
  class match_results ;
typedef match_results <const char*> cmatch ;
typedef match_results <const wchar_t *> wcmatch ;
typedef match_results <string :: const_iterator> smatch ;
typedef match_results <wstring :: const_iterator> wsmatch ;

    // NAMESPACE regex_constants
namespace regex_constants {
  typedef T1 syntax_option_type ;
  static const syntax_option_type
    awk, basic, collate, ECMAScript, egrep,
    extended, grep, icase, nosubs, optimize ;
  typedef T2 match_flag_type ;
  static const match_flag_type match_any, match_default,
    match_not_bol, match_not_bow, match_continuous,
    match_not_eol, match_not_eow, match_not_null,
    match_prev_avail ;
  typedef T3 error_type;
  static const error_type error_badbrace, error_badrepeat,
    error_brace, error_brack, error_collate,
    error_complexity, error_ctype, error_escape,
    error_paren, error_range, error_space, error_stack,
    error_backref ;
  }

    // CLASS regex_error
class regex_error;

    // FUNCTION TEMPLATE regex_match
template <class BidIt, class Alloc, class Elem,
  class RXtraits>
    bool regex_match(BidIt first, Bidit last,
      match_results <BidIt, Alloc>&,
      const basic_regex <Elem, RXtraits>&,
      match_flag_types = match_default);
template <class BidIt, class Elem, class RXtraits>
  bool regex_match(BidIt first, Bidit last,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);

template <class Elem, class Alloc, class RXtraits>

  bool regex_match(const Elem*,
    match_results <const Elem*, Alloc>&,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);
template <class Elem, class RXtraits>
  bool regex_match(const Elem*,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);

template <class IOtraits, class IOalloc,
  class Alloc, class Elem, class RXtraits>
  bool regex_match(
    const basic_string <Elem, IOtraits, IOalloc>&,
    match_results <typename
      basic_string <
        Elem, IOtraits, IOalloc>:: const_iterator,
        Alloc>&,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);
template <class IOtraits, class IOalloc,
  class Alloc, class Elem, class RXtraits>
  bool regex_match(
    const basic_string <Elem, IOtraits, IOalloc>&,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);

    // FUNCTION TEMPLATE regex_search
template <class BidIt, class Alloc,
  class Elem, class RXtraits>
  bool regex_search(BidIt first, Bidit last,
    match_results <BidIt, Alloc>&,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);
template <class BidIt, class Elem, class RXtraits>
  bool regex_search(BidIt first, Bidit last,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);

template <class Elem, class Alloc, class RXtraits>
  bool regex_search(const Elem*,
    match_results <const Elem*, Alloc>&,
    const basic_regex <Elem, RXtraits>&,
    match_flag_types = match_default);
template <class Elem, class RXtraits>
  bool regex_search(const Elem*,

  const basic_regex <Elem, RXtraits>&,
  match_flag_types = match_default);

template <class IOtraits, class IOalloc,
  class Alloc, class Elem, class RXtraits>
  bool regex_search(
    const basic_string <Elem , IOtraits , IOalloc>& ,
    match_results <typename
      basic_string <
        Elem, IOtraits, IOalloc>:: const_iterator ,
        Alloc>&,
    const basic_regex <Elem, RXtraits>& ,
    match_flag_types = match_default);
template <class IOtraits, class IOalloc ,
  class Alloc, class Elem, class RXtraits>
  bool regex_search(
    const basic_string <Elem , IOtraits , IOalloc>& ,
    const basic_regex <Elem , RXtraits>& ,
    match_flag_types = match_default);

    // FUNCTION TEMPLATE regex_replace
template <class OutIt, class BidIt,
  class RXtraits, class Elem>
  OutIt regex_replace (OutIt out , BidIt first , BidIt last ,
    const basic_regex <Elem , RXtraits>& ,
    const basic_string <Elem>& fmt ,
    match_flag_type flags = match_default);
template <class RXtraits , class Elem>
  basic_string <Elem> regex_replace (
    const basic_string <Elem>&,
    const basic_regex <Elem, RXtraits>&,
    const basic_string <Elem>& fmt,
    match_flag_type flags = match_default);

    // REGULAR EXPRESSION ITERATORS
template <class BidIt,
  class Elem = iterator_traits <BidIt>:: value_type,
  class RXtraits = regex_traits <Elem>>
    class regex_iterator ;
typedef regex_iterator <const char*> cregex_iterator ;
typedef regex_iterator <const wchar_t *> wcregex_iterator ;
typedef regex_iterator <string :: const_iterator>
  sregex_iterator ;
typedef regex_iterator <wstring :: const_iterator>
  wsregex_iterator ;

template <class BidIt, class Elem =
  iterator_traits <BidIt>:: value_type,
  class RXtraits = regex_traits <Elem>>
    class regex_token_iterator ;
typedef regex_token_iterator <const char*>
  cregex_token_iterator ;
typedef regex_token_iterator <const wchar_t *>
  wcregex_token_iterator ;
typedef regex_token_iterator <string :: const_iterator>
  sregex_token_iterator ;
typedef regex_token_iterator <wstring :: const_iterator>
  wsregex_token_iterator ;

    // STREAM INSERTER
template <class Elem, class IOtraits,
  class Alloc, class BidIt>
  basic_ostream <Elem, IOtraits>&
  operator <<( basic_ostream <Elem, IOtraits>&,
    const sub_match <BidIt>&);

    // TEMPLATE swap FUNCTIONS
template <class Elem, class RXtraits>
  void swap(basic_regex <Elem, RXtraits>& left,
    basic_regex <Elem, RXtraits>& right) throw ();
template <class Elem, class IOtraits,
  class BidIt, class Alloc>
  void swap(match_results <BidIt, Alloc>& left,
    match_results <BidIt, Alloc>& right) throw ();

    // COMPARISON OPERATORS FOR match_results
template <class BidIt , class Alloc>
  bool operator ==( const match_results <BidIt, Alloc>&,
    const match_results <BidIt, Alloc>&);
template <class BidIt , class Alloc>
  bool operator !=( const match_results <BidIt, Alloc>&,
    const match_results <BidIt , Alloc>&);

    // COMPARISON OPERATORS FOR sub_match
template <class BidIt>
  bool operator ==( const sub_match <BidIt >&,
    const sub_match <BidIt>&);
template <class BidIt>
  bool operator !=( const sub_match <BidIt >&,
    const sub_match <BidIt>&);

template <class BidIt >
  bool operator <( const sub_match <BidIt >&,
    const sub_match <BidIt>&);
template <class BidIt>
  bool operator <=( const sub_match <BidIt >&,
    const sub_match <BidIt>&);
template <class BidIt>
  bool operator>( const sub_match <BidIt >&,
    const sub_match <BidIt >&);
template <class BidIt >
  bool operator>=( const sub_match <BidIt >&,
    const sub_match <BidIt >&);

template <class BidIt, class IOtraits, class Alloc>
  bool operator ==(
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&,
    const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator !=(
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&,
    const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator <(
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&,
    const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator <=(
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&,
    const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator>(
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&,
    const sub_match <BidIt >&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator>=(

  const basic_string <
    typename iterator_traits <BidIt >:: value_type,
    IOtraits, Alloc>&,
  const sub_match <BidIt >&);

template <class BidIt, class IOtraits, class Alloc>
  bool operator ==( const sub_match <BidIt >&,
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator !=( const sub_match <BidIt >&,
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator <( const sub_match <BidIt >&,
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator <=( const sub_match <BidIt >&,
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator>( const sub_match <BidIt >&,
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&);
template <class BidIt, class IOtraits, class Alloc>
  bool operator>=( const sub_match <BidIt >&,
    const basic_string <
      typename iterator_traits <BidIt >:: value_type,
      IOtraits, Alloc>&);

template <class BidIt >
  bool operator ==(
    const typename iterator_traits <BidIt >:: value_type*,
    const sub_match <BidIt >&);
template <class BidIt >
  bool operator !=(
    const typename iterator_traits <BidIt >:: value_type*,
    const sub_match <BidIt >&);
template <class BidIt >

  bool operator <(
    const typename iterator_traits <BidIt >:: value_type*,
    const sub_match <BidIt >&);
template <class BidIt >
  bool operator <=(
    const typename iterator_traits <BidIt >:: value_type*,
    const sub_match <BidIt >&);
template <class BidIt >
  bool operator>(
    const typename iterator_traits <BidIt >:: value_type*,
    const sub_match <BidIt >&);
template <class BidIt >
  bool operator>=(
    const typename iterator_traits <BidIt >:: value_type*,
    const sub_match <BidIt >&);

template <class BidIt >
  bool operator ==( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt >
  bool operator !=( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
  bool operator <( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
  bool operator <=( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
  bool operator>( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type *);
template <class BidIt>
  bool operator>=( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type *);

template <class BidIt>
  bool operator ==(
    const typename iterator_traits <BidIt >:: value_type&,
    const sub_match <BidIt >&);
template <class BidIt>
  bool operator !=(
    const typename iterator_traits <BidIt >:: value_type&,
    const sub_match <BidIt >&);
template <class BidIt>
  bool operator <(

    const typename iterator_traits <BidIt >:: value_type&,
    const sub_match <BidIt >&);
template <class BidIt>
  bool operator <=(
    const typename iterator_traits <BidIt >:: value_type&,
    const sub_match <BidIt >&);
template <class BidIt>
  bool operator>(
    const typename iterator_traits <BidIt >:: value_type&,
    const sub_match <BidIt >&);
template <class BidIt>
  bool operator>=(
    const typename iterator_traits <BidIt >:: value_type&,
    const sub_match <BidIt >&);

template <class BidIt>
  bool operator ==( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
  bool operator !=( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
  bool operator <( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
  bool operator <=( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
  bool operator>( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type &);
template <class BidIt>
  bool operator>=( const sub_match <BidIt >&,
    const typename iterator_traits <BidIt >:: value_type &);
} }

namespace std {     // C++ standard library
 namespace tr1 {    // TR1 additions

    // CLASS TEMPLATE unordered_set
template < class Key,

  class Hash = hash <Key>,
  class Pred = equal_to <Key >,
  class Alloc = allocator <Key >>
    class unordered_set ;

    // CLASS TEMPLATE unordered_multiset
template <class Key,
  class Hash = hash <Key >,
  class Pred = equal_to <Key >,
  class Alloc = allocator <Key >>
    class unordered_multiset ;

    // FUNCTION TEMPLATES swap
template <class Key, class Hash, class Pred, class Alloc>
void swap (unordered_set (Key, Hash, Pred, Alloc>& left,
    unordered_set (Key, Hash, Pred, Alloc>& right);
template <class Key, class Hash, class Pred, class Alloc>
void swap ( unordered_multiset (Key, Hash, Pred, Alloc>& left,
  unordered_multiset (Key, Hash, Pred, Alloc>& right);

    // CLASS TEMPLATE unordered_set
template <class Key,
  class Hash = hash <Key >,
  class Pred = equal_to <Key >,
  class Alloc = allocator <Key >>
  class unordered_set {
public :

    // NESTED TYPES
  typedef Key key_type ;
  typedef Hash hasher ;
  typedef Pred key_equal ;
  typedef Key value_type ;

  typedef Alloc allocator_type ;
  typedef Alloc :: pointer pointer ;
  typedef Alloc :: const_pointer const_pointer ;
  typedef Alloc :: reference reference ;
  typedef Alloc :: const_reference const_reference ;

  typedef T0 iterator ;
  typedef T1 const_iterator ;
  typedef T2 local_iterator ;
  typedef T3 const_local_iterator ;
  typedef T4 size_type ;

  typedef T5 difference_type ;

    // CONSTRUCTING AND ASSIGNING
  explicit unordered_set (
    size_type n = n0 , // implementation-defined
    const hasher & h = hasher (),
    const key_equal & comp = key_equal (),
    const allocator_type & alloc = allocator_type ());
  template <class InIt>
    unordered_set (InIt first, InIt last,
    size_type n = n0 , // implementation-defined
    const hasher & h = hasher (),
    const key_equal & comp = key_equal (),
    const allocator_type & alloc = allocator_type ());
  unordered_set (const unordered_set & right);
  unordered_set & operator= (const unordered_set & right );

    // MODIFYING
  pair <iterator, bool> insert (const value_type & val);
  iterator insert (
    iterator where, const value_type & val);
  const_iterator insert (
    const_iterator where, const value_type& val);
  template <class InIt>
    void insert (InIt first, InIt last);

  iterator erase (iterator where);
  const_iterator erase ( const_iterator where);
  size_type erase (const Key & key);
  iterator erase (
    iterator first, iterator last);
  const_iterator erase (
    const_iterator first, const_iterator last);
  void clear ();

  void swap (unordered_set & right);

    // ITERATING
  iterator begin ();
  iterator end ();
  const_iterator begin () const;
  const_iterator end () const ;

    // SEARCHING
  iterator find (const Key & key);

  const_iterator find (const Key & key) const;
  size_type count (const Key & key) const;
  pair <iterator, iterator>
    equal_range (const Key & key);
  pair <const_iterator, const_iterator>
    equal_range (const Key & key) const;

    // QUERYING
  size_type size () const ;
  size_type max_size () const;
  bool empty () const;

  allocator_type get_allocator () const;
  hasher hash_function () const ;
  key_equal key_eq () const ;

    // TUNING
  local_iterator begin (size_type n);
  const_local_iterator begin (size_type n) const;
  local_iterator end (size_type n);
  const_local_iterator end (size_type n) const ;

  size_type bucket_count () const ;
  size_type max_bucket_count () const ;
  size_type bucket_size (size_type n) const;
  size_type bucket (const key_type & val) const ;

  float load_factor () const ;
  float max_load_factor () const;
  void max_load_factor (float fact);
  void rehash (size_type n);
  };

    // CLASS TEMPLATE unordered_multiset
template <class Key,
  class Ty,
  class Hash = hash <Key >,
  class Pred = equal_to <Key >,
  class Alloc = allocator <Key >
  class unordered_multiset {
    // CONTENTS ARE THE SAME AS unordered_set
  };

} }

namespace std {    // C++ standard library
 namespace tr1 {   // TR1 additions

    // CLASS TEMPLATE unordered_map
template <class Key, class Ty,
  class Hash = hash <Key>,
  class Pred = equal_to <Key>,
  class Alloc = allocator <pair <const Key, Ty>>>
    class unordered_map ;

    // CLASS TEMPLATE unordered_multimap
template <class Key, class Ty,
  class Hash = hash <Key>,
  class Pred = equal_to <Key>,
  class Alloc = allocator <pair <const Key, Ty>>>
  class unordered_multimap ;

    // FUNCTION TEMPLATES swap
template <class Key, class Ty, class Hash,
  class Pred, class Alloc>
void swap (unordered_map (Key, Ty, Hash, Pred, Alloc>& left,
  unordered_map (Key, Ty, Hash, Pred, Alloc>& right);
template <class Key, class Ty, class Hash, class Pred,
  class Alloc>
void swap (
  unordered_multimap (Key, Ty, Hash, Pred, Alloc>& left,
  unordered_multimap (Key, Ty, Hash, Pred, Alloc>& right);

    // CLASS TEMPLATE unordered_map
template <class Key,
  class Ty,
  class Hash = hash <Key>,
  class Pred = equal_to <Key>,
  class Alloc = allocator <pair <const Key, Ty>>>
  class unordered_map {
public :

    // NESTED TYPES
  typedef Key key_type ;
  typedef Hash hasher ;
  typedef Pred key_equal ;
  typedef pair <const Key, Ty> value_type ;
  typedef Ty mapped_type ;

  typedef Alloc allocator_type ;
  typedef Alloc :: pointer pointer ;
  typedef Alloc :: const_pointer const_pointer ;
  typedef Alloc :: reference reference ;
  typedef Alloc :: const_reference const_reference ;

  typedef T0 iterator ;
  typedef T1 const_iterator ;
  typedef T2 local_iterator ;
  typedef T3 const_local_iterator ;
  typedef T4 size_type ;
  typedef T5 difference_type ;

    // CONSTRUCTING AND ASSIGNING
explicit unordered_map (
  size_type n = n0, // implementation-defined
  const hasher & h = hasher (),
  const key_equal & comp = key_equal (),
  const allocator_type & alloc = allocator_type ());
template <class InIt>
  unordered_map (InIt first, InIt last,
  size_type n = n0, // implementation-defined
  const hasher & h = hasher (),
  const key_equal & comp = key_equal (),
  const allocator_type & alloc = allocator_type ());
unordered_map (const unordered_map & right);
unordered_map & operator= (const unordered_map & right);

    // MODIFYING
  pair <iterator, bool> insert (const value_type & val);
  iterator insert (
    iterator where, const value_type & val);
  const_iterator insert (
    const_iterator where, const value_type& val);
  template <class InIt>
    void insert (InIt first, InIt last);

  iterator erase (iterator where);
  const_iterator erase ( const_iterator where);
  size_type erase (const Key & keyval);
  iterator erase (
    iterator first, iterator last);
  const_iterator erase (
    const_iterator first, const_iterator last);

  void clear ();

  void swap (unordered_map & right);

    // ITERATING
  iterator begin ();
  iterator end ();
  const_iterator begin () const;
  const_iterator end () const ;

    // SEARCHING
  iterator find (const Key & keyval);
  const_iterator find (const Key & keyval) const;
  size_type count (const Key & keyval) const;
  pair <iterator, iterator>
    equal_range (const Key & keyval);
  pair <const_iterator, const_iterator>
    equal_range (const Key & keyval) const;
  mapped_type & operator []( const Key & keyval);
  const mapped_type & operator []( const Key & keyval) const;

    // QUERYING
  size_type size () const ;
  size_type max_size () const;
  bool empty () const;

  allocator_type get_allocator () const;
  hasher hash_function () const ;
  key_equal key_eq () const ;

    // TUNING
  local_iterator begin (size_type n);
  const_local_iterator begin (size_type n) const;
  local_iterator end (size_type n);
  const_local_iterator end (size_type n) const ;

  size_type bucket_count () const;
  size_type max_bucket_count () const ;
  size_type bucket_size (size_type n) const;
  size_type bucket (const key_type & val) const ;

  float load_factor () const ;
  float max_load_factor () const ;
  void max_load_factor (float fact);
  void rehash (size_type n);

  };

    // CLASS TEMPLATE unordered_multimap
template <class Key,
  class Ty,
  class Hash = hash <Key>,
  class Pred = equal_to <Key>,
  class Alloc = allocator <pair <const Key, Ty>>>
  class unordered_multimap {
    // CONTENTS ARE THE SAME AS unordered_map WITHOUT operator[]
  };

} }

# define FLT_RADIX <# if expression >= 2 >
# define FLT_ROUNDS < integer rvalue >
# define FLT_EVAL_METHOD <# if expression >
# define DECIMAL_DIG <# if expression >= 10 >

# define DBL_DIG <# if expression >= 10 >
# define DBL_EPSILON < double constant <= 10^-9 >
# define DBL_MANT_DIG <# if expression >
# define DBL_MAX < double constant >= 10³⁷ >
# define DBL_MAX_10_EXP <# if expression >= 37 >
# define DBL_MAX_EXP <# if expression >
# define DBL_MIN < double constant <= 10^-37 >
# define DBL_MIN_10_EXP <# if expression <= -37 >
# define DBL_MIN_EXP <# if expression >

# define FLT_DIG <# if expression >= 6 >
# define FLT_EPSILON < float constant <= 10^-5 >
# define FLT_MANT_DIG <# if expression >
# define FLT_MAX < float constant >= 10³⁷ >
# define FLT_MAX_10_EXP <# if expression >= 37 >
# define FLT_MAX_EXP <# if expression >
# define FLT_MIN < float constant <= 10^-37 >
# define FLT_MIN_10_EXP <# if expression <= -37 >
# define FLT_MIN_EXP <# if expression >

# define LDBL_DIG <# if expression >= 10 >
# define LDBL_EPSILON < long double constant <= 10^-9 >

# define LDBL_MANT_DIG <# if expression >
# define LDBL_MAX < long double constant >= 10³⁷ >
# define LDBL_MAX_10_EXP <# if expression >= 37 >
# define LDBL_MAX_EXP <# if expression >
# define LDBL_MIN < long double constant <= 10^-37 >
# define LDBL_MIN_10_EXP <# if expression <= -37 >
# define LDBL_MIN_EXP <# if expression >

    // MACROS
#define HUGE_VAL <double rvalue>
#define HUGE_VALF <float rvalue>
#define HUGE_VALL <long double rvalue>

#define INFINITY <float rvalue>
#define NAN <float rvalue>

#define FP_FAST_FMA <integer constant expression>
#define FP_FAST_FMAF <integer constant expression>
#define FP_FAST_FMAL <integer constant expression>

#define FP_INFINITE <integer constant expression>
#define FP_NAN <integer constant expression>
#define FP_NORMAL <integer constant expression>
#define FP_SUBNORMAL <integer constant expression>
#define FP_ZERO <integer constant expression>

#define FP_ILOGB0 <integer constant expression>
#define FP_ILOGBNAN <integer constant expression>

#define MATH_ERRNO       1
#define MATH_ERREXCEPT    2
#define math_errhandling <int rvalue // [0,4)>

    // TYPES
typedef f-type double_t ;
typedef f-type float_t ;

    // GENERIC FUNCTION MACROS macros in C, functions in C++
#define signbit (x) <int rvalue>

#define fpclassify (x) <int rvalue>

#define isfinite (x) <int rvalue>
#define isinf (x) <int rvalue>
#define isnan (x) <int rvalue>
#define isnormal (x) <int rvalue>

#define isgreater (x, y) <int rvalue>
#define isgreaterequal (x, y) <int rvalue>
#define isless (x, y) <int rvalue>
#define islessequal (x, y) <int rvalue>
#define islessgreater (x, y) <int rvalue>
#define isunordered (x, y) <int rvalue>

    // FUNCTIONS
double abs (double x); // C++ only
float abs (float x); // C++ only
long double abs (long double x); // C++ only

double acos (double x);
float acos (float x); // C++ only
long double acos (long double x); // C++ only
float acosf (float x); // required with C99
long double acosl (long double x); // required with C99

double asin (double x);
float asin (float x); // C++ only
long double asin (long double x); // C++ only
float asinf (float x); // required with C99
long double asinl (long double x); // required with C99

double atan (double x);
float atan (float x); // C++ only
long double atan (long double x); // C++ only
float atanf (float x); // required with C99
long double atanl (long double x); // required with C99

double atan2 (double y, double x);
float atan2 (float y, float x); // C++ only
long double atan2 (long double y, long double x); // C++ only
float atan2f (float y, float x); // required with C99
long double atan2l (long double y,
    long double x); // required with C99

double ceil (double x);
float ceil (float x); // C++ only
long double ceil (long double x); // C++ only

float ceilf (float x); // required with C99
long double ceill (long double x); // required with C99

double cos (double x);
float cos (float x); // C++ only
long double cos (long double x); // C++ only
float cosf (float x); // required with C99
long double cosl (long double x); // required with C99

double cosh (double x);
float cosh (float x); // C++ only
long double cosh (long double x); // C++ only
float coshf (float x); // required with C99
long double coshl (long double x); // required with C99

double exp (double x);
float exp (float x); // C++ only
long double exp (long double x); // C++ only
float expf (float x); // required with C99
long double expl (long double x); // required with C99

double fabs (double x);
float fabs (float x); // C++ only
long double fabs (long double x); // C++ only
float fabsf (float x); // required with C99
long double fabsl (long double x); // required with C99

double floor (double x);
float floor (float x); // C++ only
long double floor (long double x); // C++ only
float floorf (float x); // required with C99
long double floorl (long double x); // required with C99

double fmod (double x, double y);
float fmod (float x, float y); // C++ only
long double fmod (long double x, long double y); // C++ only
float fmodf (float x, float y); // required with C99
long double fmodl (long double x,
    long double y); // required with C99

double frexp (double x, int * pexp);
float frexp (float x, int *pexp); // C++ only
long double frexp (long double x, int *pexp); // C++ only
float frexpf (float x, int * pexp); // required with C99
long double frexpl (long double x, int *pexp);// required with C99


double ldexp (double x, int ex);
float ldexp (float x, int ex); // C++ only
long double ldexp (long double x, int ex); // C++ only
float ldexpf (float x, int ex); // required with C99
long double ldexpl (long double x, int ex); // required with C99

double log (double x);
float log (float x); // C++ only
long double log (long double x); // C++ only
float logf (float x); // required with C99
long double logl (long double x); // required with C99

double log10 (double x);
float log10 (float x); // C++ only
long double log10 (long double x); // C++ only
float log10f (float x); // required with C99
long double log10l (long double x); // required with C99

double modf (double x, double *pint);
float modf (float x, float *pint); // C++ only
long double modf (long double x,
    long double * pint); // C++ only
float modff (float x, float * pint); // required with C99
long double modfl (long double x,
    long double * pint); // required with C99

double pow (double x, double y);
float pow (float x, float y); // C++ only
long double pow (long double x, long double y); // C++ only
double pow (double x, int y); // C++ only
float pow (float x, int y); // C++ only
long double pow (long double x, int y); // C++ only
float powf (float x, float y); // required with C99
long double powl (long double x,
    long double y); // required with C99

double sin (double x);
float sin (float x); // C++ only
long double sin (long double x); // C++ only
float sinf (float x); // required with C99
long double sinl (long double x); // required with C99

double sinh (double x);
float sinh (float x); // C++ only

long double sinh (long double x); // C++ only
float sinhf (float x); // required with C99
long double sinhl (long double x); // required with C99

double sqrt (double x);
float sqrt (float x); // C++ only
long double sqrt (long double x); // C++ only
float sqrtf (float x); // required with C99
long double sqrtl (long double x); // required with C99

double tan (double x);
float tan (float x); // C++ only
long double tan (long double x); // C++ only
float tanf (float x); // required with C99
long double tanl (long double x); // required with C99

double tanh (double x);
float tanh (float x); // C++ only
long double tanh (long double x); // C++ only
float tanhf (float x); // required with C99
long double tanhl (long double x); // required with C99

double acosh (double x);
float acosh (float x); // C++ only
long double acosh (long double x); // C++ only
float acoshf (float x);
long double acoshl (long double x);

double asinh (double x);
float asinh (float x); // C++ only
long double asinh (long double x); // C++ only
float asinhf (float x);
long double asinhl (long double x);

double atanh (double x);
float atanh (float x); // C++ only
long double atanh (long double x); // C++ only
float atanhf (float x);
long double atanhl (long double x);

double cbrt (double x);
float cbrt (float x); // C++ only
long double cbrt (long double x); // C++ only
float cbrtf (float x);
long double cbrtl (long double x);


double copysign (double x, double y);
float copysign (float x, float y); // C++ only
long double copysign (long double x,
  long double y); // C++ only
float copysignf (float x, float y);
long double copysignl (long double x, long double y);

double erf (double x);
float erf (float x); // C++ only
long double erf (long double x); // C++ only
float erff (float x);
long double erfl (long double x);

double erfc (double x);
float erfc (float x); // C++ only
long double erfc (long double x); // C++ only
float erfcf (float x);
long double erfcl (long double x);

double exp2 (double x);
float exp2 (float x); // C++ only
long double exp2 (long double x); // C++ only
float exp2f (float x);
long double exp2l (long double x);

double expm1 (double x);
float expm1 (float x); // C++ only
long double expm1 (long double x); // C++ only
float expm1f (float x);
long double expm1l (long double x);

double fdim (double x, double y);
float fdim (float x, float y); // C++ only
long double fdim (long double x, long double y); // C++ only
float fdimf (float x, float y);
long double fdiml (long double x, long double y);

double fma (double x, double y, double z);
float fma (float x, float y, float z); // C++ only
long double fma (long double x, long double y,
  long double z); // C++ only
float fmaf (float x, float y, float z);
long double fmal (long double x, long double y,
  long double z);


double fmax (double x, double y);
float fmax (float x, float y); // C++ only
long double fmax (long double x, long double y); // C++ only
float fmaxf (float x, float y);
long double fmaxl (long double x, long double y);

double fmin (double x, double y);
float fmin (float x, float y); // C++ only
long double fmin (long double x, long double y); // C++ only
float fminf (float x, float y);
long double fminl (long double x, long double y);

double hypot (double x, double y);
float hypot (float x, float y); // C++ only
long double hypot (long double x, long double y); // C++ only
float hypotf (float x, float y);
long double hypotl (long double x, long double y);

int ilogb (double x);
int ilogb (float x); // C++ only
int ilogb (long double x); // C++ only
int ilogbf (float x);
int ilogbl (long double x);

double lgamma (double x);
float lgamma (float x); // C++ only
long double lgamma (long double x); // C++ only
float lgammaf (float x);
long double lgammal (long double x);

long long llrint (double x);
long long llrint (float x); // C++ only
long long llrint (long double x); // C++ only
long long llrintf (float x);
long long llrintl (long double x);

long long llround (double x);
long long llround (float x); // C++ only
long long llround (long double x); // C++ only
long long llroundf (float x);
long long llroundl (long double x);

double log1p (double x);
float log1p (float x); // C++ only

long double log1p (long double x); // C++ only
float log1pf (float x);
long double log1pl (long double x);

double log2 (double x);
float log2 (float x); // C++ only
long double log2 (long double x); // C++ only
float log2f (float x);
long double log2l (long double x);

double logb (double x);
float logb (float x); // C++ only
long double logb (long double x); // C++ only
float logbf (float x);
long double logbl (long double x);

long lrint (double x);
long lrint (float x); // C++ only
long lrint (long double x); // C++ only
long lrintf (float x);
long lrintl (long double x);

long lround (double x);
long lround (float x); // C++ only
long lround (long double x); // C++ only
long lroundf (float x);
long lroundl (long double x);

double nan (const char *str);
float nanf (const char *str);
long double nanl (const char *str);

double nearbyint (double x);
float nearbyint (float x); // C++ only
long double nearbyint (long double x); // C++ only
float nearbyintf (float x);
long double nearbyintl (long double x);

double nextafter (double x, double y);
float nextafter (float x, float y); // C++ only
long double nextafter (long double x,
  long double y); // C++ only
float nextafterf (float x, float y);
long double nextafterl (long double x, long double y);


double nexttoward (double x, long double y);
float nexttoward (float x, long double y); // C++ only
long double nexttoward (long double x,
  long double y); // C++ only
float nexttowardf (float x, long double y);
long double nexttowardl (long double x, long double y);

double remainder (double x, double y);
float remainder (float x, float y); // C++ only
long double remainder (long double x,
  long double y); // C++ only
float remainderf (float x, float y);
long double remainderl (long double x, long double y);

double remquo (double x, double y, int *pquo);
float remquo (float x, float y, int *pquo); // C++ only
long double remquo (long double x, long double y,
  int *pquo); // C++ only
float remquof (float x, float y, int * pquo);
long double remquol (long double x, long double y,
  int *pquo);

double rint (double x);
float rint (float x); // C++ only
long double rint (long double x); // C++ only
float rintf (float x);
long double rintl (long double x);

double round (double x);
float round (float x); // C++ only
long double round (long double x); // C++ only
float roundf (float x);
long double roundl (long double x);

double scalbln (double x, long ex);
float scalbln (float x, long ex); // C++ only
long double scalbln (long double x, long ex); // C++ only
float scalblnf (float x, long ex);
long double scalblnl (long double x, long ex);

double scalbn (double x, int ex);
float scalbn (float x, int ex); // C++ only
long double scalbn (long double x, int ex); // C++ only
float scalbnf (float x, int ex);
long double scalbnl (long double x, int ex);


double tgamma (double x);
float tgamma (float x); // C++ only
long double tgamma (long double x); // C++ only
float tgammaf (float x);
long double tgammal (long double x);

double trunc (double x);
float trunc (float x); // C++ only
long double trunc (long double x); // C++ only
float truncf (float x);
long double truncl (long double x);

double laguerre (unsigned n, double x);
float laguerre (unsigned n, float x); // C++ only
long double laguerre (unsigned n, long double x); // C++ only
float laguerref (unsigned n, float x);
long double laguerrel (unsigned n, long double x);

double assoc_laguerre (unsigned n, unsigned m,
  double x);
float assoc_laguerre (unsigned n, unsigned m,
  float x); // C++ only
long double assoc_laguerre (unsigned n, unsigned m,
  long double x); // C++ only
float assoc_laguerref (unsigned n, unsigned m,
  float x);
long double assoc_laguerrel (unsigned n, unsigned m,
  long double x);

double legendre (unsigned l, double x);
float legendre (unsigned l, float x); // C++ only
long double legendre (unsigned l, long double x); // C++ only
float legendref (unsigned l, float x);
long double legendrel (unsigned l, long double x);

double assoc_legendre (unsigned l, unsigned m,
  double x);
float assoc_legendre (unsigned l, unsigned m,
  float x); // C++ only
long double assoc_legendre (unsigned l, unsigned m,
  long double x); // C++ only
float assoc_legendref (unsigned l, unsigned m,
  float x);
long double assoc_legendrel (unsigned l, unsigned m,

  long double x);

double sph_legendre (unsigned l, unsigned m,
  double theta);
float sph_legendre (unsigned l, unsigned m,
  float theta); // C++ only
long double sph_legendre (unsigned l, unsigned m,
  long double theta); // C++ only
float sph_legendref (unsigned l, unsigned m,
  float theta);
long double sph_legendrel (unsigned l, unsigned m,
  long double theta);

double beta (double x, double y);
float beta (float x, float y); // C++ only
long double beta (long double x, long double y); // C++ only
float betaf (float x, float y);
long double betal (long double x, long double y);

double ellint_1 (double k, double phi);
float ellint_1 (float k, float phi); // C++ only
long double ellint_1 (long double k,
  long double phi); // C++ only
float ellint_1f (float k, float phi);
long double ellint_1l (long double k, long double phi);

double ellint_2 (double k, double phi);
float ellint_2 (float k, float phi); // C++ only
long double ellint_2 (long double k,
  long double phi); // C++ only
float ellint_2f (float k, float phi);
long double ellint_2l (long double k, long double phi);

double ellint_3 (double k, double nu,
  double phi);
float ellint_3 (float k, float nu,
  float phi); // C++ only
long double ellint_3 (long double k, long double nu,
  long double phi); // C++ only
float ellint_3f (float k, float nu,
  float phi);
long double ellint_3l (long double k, long double nu,
  long double phi);

double comp_ellint_1 (double k);

float comp_ellint_1 (float k); // C++ only
long double comp_ellint_1 (long double k); // C++ only
float comp_ellint_1f (float k);
long double comp_ellint_1l (long double k);

double comp_ellint_2 (double k);
float comp_ellint_2 (float k); // C++ only
long double comp_ellint_2 (long double k); // C++ only
float comp_ellint_2f (float k);
long double comp_ellint_2l (long double k);

double comp_ellint_3 (double k, double nu);
float comp_ellint_3 (float k, float nu); // C++ only
long double comp_ellint_3 (long double k,
  long double nu); // C++ only
float comp_ellint_3f (float k, float nu);
long double comp_ellint_3l (long double k, long double nu);

double cyl_bessel_i (double nu, double x);
float cyl_bessel_i (float nu, float x); // C++ only
long double cyl_bessel_i (long double nu,
  long double x); // C++ only
float cyl_bessel_if (float nu, float x);
long double cyl_bessel_il (long double nu, long double x);

double cyl_bessel_j (double nu, double x);
float cyl_bessel_j (float nu, float x); // C++ only
long double cyl_bessel_j (long double nu,
  long double x); // C++ only
float cyl_bessel_jf (float nu, float x);
long double cyl_bessel_jl (long double nu, long double x);

double cyl_bessel_k (double nu, double x);
float cyl_bessel_k (float nu, float x); // C++ only
long double cyl_bessel_k (long double nu,
  long double x); // C++ only
float cyl_bessel_kf (float nu, float x);
long double cyl_bessel_kl (long double nu, long double x);

double sph_bessel (unsigned n, double x);
float sph_bessel (unsigned n, float x); // C++ only
long double sph_bessel (unsigned n, long double x); // C++ only
float sph_besself (unsigned n, float x);
long double sph_bessell (unsigned n, long double x);


double cyl_neumann (double nu, double x);
float cyl_neumann (float nu, float x); // C++ only
long double cyl_neumann (long double nu,
  long double x); // C++ only
float cyl_neumannf (float nu, float x);
long double cyl_neumannl (long double nu, long double x);

double sph_neumann (unsigned n, double x);
float sph_neumann (unsigned n, float x); // C++ only
long double sph_neumann (unsigned n,
  long double x); // C++ only
float sph_neumannf (unsigned n, float x);
long double sph_neumannl (unsigned n, long double x);

double expint (double x);
float expint (float x); // C++ only
long double expint (long double x); // C++ only
float expintf (float x);
long double expintl (long double x);

double hermite (unsigned n, double x);
float hermite (unsigned n, float x); // C++ only
long double hermite (unsigned n, long double x); // C++ only
float hermitef (unsigned n, float x);
long double hermitel (unsigned n, long double x);

double riemann_zeta (double x);
float riemann_zeta (float x); // C++ only
long double riemann_zeta (long double x); // C++ only
float riemann_zetaf (float x);
long double riemann_zetal (long double x);

namespace std {
template <class Arg, class Result>
  struct unary_function ;
template <class Arg1, class Arg2, class Result>
  struct binary_function ;
template <class Ty>
  struct plus ;
template <class Ty>
  struct minus ;

template <class Ty>
  struct multiplies ;
template <class Ty>
  struct divides ;
template <class Ty>
  struct modulus ;
template <class Ty>
  struct negate ;
template <class Ty>
  struct equal_to ;
template <class Ty>
  struct not_equal_to ;
template <class Ty>
  struct greater ;
template <class Ty>
  struct less ;
template <class Ty>
  struct greater_equal ;
template <class Ty>
  struct less_equal ;
template <class Ty>
  struct logical_and ;
template <class Ty>
  struct logical_or ;
template <class Ty>
  struct logical_not ;
template <class Fn1>
  struct unary_negate ;
template <class Fn2>
  struct binary_negate ;
template <class Fn2>
  class binder1st ;
template <class Fn2>
  class binder2nd ;
template <class Arg, class Result>
  class pointer_to_unary_function ;
template <class Arg1, class Arg2, class Result>
  class pointer_to_binary_function ;
template <class Result, class Ty>
  struct mem_fun_t ;
template <class Result, class Ty, class Arg>
  struct mem_fun1_t ;
template <class Result, class Ty>
  struct const_mem_fun_t ;
template <class Result, class Ty, class Arg>

  struct const_mem_fun1_t ;
template <class Result, class Ty>
  struct mem_fun_ref_t ;
template <class Result, class Ty, class Arg>
  struct mem_fun1_ref_t ;
template <class Result, class Ty>
  struct const_mem_fun_ref_t ;
template <class Result, class Ty, class Arg>
  struct const_mem_fun1_ref_t ;

    // TEMPLATE FUNCTIONS
template <class Fn1>
  unary_negate <Fn1> not1 (const Fn1 & func);
template <class Fn2>
  binary_negate <Fn2> not2 (const Fn2 & func);
template <class Fn2, class Ty>
  binder1st <Fn2> bind1st (const Fn2 & func, const Ty& left);
template <class Fn2, class Ty>
  binder2nd <Fn2> bind2nd (
    const Fn2 & func, const Ty& right);
template <class Arg, class Result>
  pointer_to_unary_function <Arg, Result>
    ptr_fun (Result (*)( Arg));
template <class Arg1, class Arg2, class Result>
  pointer_to_binary_function <Arg1, Arg2, Result>
    ptr_fun (Result (*)( Arg1, Arg2));
template <class Result, class Ty>
  mem_fun_t <Result, Ty> mem_fun (Result (Ty::* pm)());
template <class Result, class Ty, class Arg>
  mem_fun1_t <Result, Ty, Arg> mem_fun (
    Result (Ty::* pm)(Arg left));
template <class Result, class Ty>
  const_mem_fun_t <Result, Ty> mem_fun (
    Result (Ty::* pm)() const);
template <class Result, class Ty, class Arg>
  const_mem_fun1_t <Result, Ty, Arg> mem_fun (
    Result (Ty::* pm)(Arg left) const);
template <class Result, class Ty>
  mem_fun_ref_t <Result, Ty> mem_fun_ref (
    Result (Ty::* pm)());
template <class Result, class Ty, class Arg>
  mem_fun1_ref_t <Result, Ty, Arg>
    mem_fun_ref (Result (Ty::* pm)(Arg left));
template <class Result, class Ty>
  const_mem_fun_ref_t <Result, Ty> mem_fun_ref (

    Result (Ty::* pm)() const);
template <class Result, class Ty, class Arg>
  const_mem_fun1_ref_t <Result, Ty, Arg>
    mem_fun_ref (Result (Ty::* pm)(Arg left) const);

  namespace tr1 {
    // REFERENCE WRAPPERS
template <class Ty> reference_wrapper <Ty>
  ref (Ty&);
template <class Ty> reference_wrapper <Ty>
  ref (reference_wrapper <Ty>&);
template <class Ty> reference_wrapper <const Ty>
  cref (const Ty&);
template <class Ty> reference_wrapper <const Ty>
  cref (const reference_wrapper <Ty>&);
template <class Ty>
  struct reference_wrapper ;

    // FUNCTION OBJECT RETURN TYPES
template <class Ty>
  struct result_of ;

    // ENHANCED MEMBER POINTER ADAPTER
template <class Ret, class Ty>
  unspecified mem_fn (Ret Ty ::*);

    // FUNCTION OBJECT WRAPPERS
class bad_function_call ;
template <class Fty>
  class function ;
template <class Fty>
  void swap (function <Fty>& f1,
    function <Fty>& f2);
template <class Fty>
  bool operator!= (const function <Fty>&,
    null_ptr_type);
template <class Fty>
  bool operator!= (null_ptr_type,
    const function <Fty>&);
template <class Fty>
  bool operator== (const function <Fty>&,
    null_ptr_type);
template <class Fty>
  bool operator== (null_ptr_type,
    const function <Fty>&);


    // ENHANCED BINDERS
template <class Fty, class T1, class T2, …, class TN>
  unspecified bind (Fty, T1, T2, …, TN);
template <class Ret,
  class Fty, class T1, class T2, …, class TN>
  unspecified bind (Fty, T1, T2, …, TN);
template <class Ret,
  class Ty, class T1, class T2, …, class TN>
  unspecified bind (Ret Ty::*, T1, T2, …, TN);

template <class Ty>
  struct is_bind_expression ;
template <class Ty>
  struct is_placeholder ;

    namespace placeholders {
extern unspecified _1 ; // _2, _3, … _M
    }// namespace placeholders
  }  // namespace tr1
}  // namespace std

namespace std {
template <class Ty>
  class allocator ;
template <>
  class allocator<void> ;
template <class FwdIt, class Ty>
  class raw_storage_iterator ;
template <class Ty>
  class auto_ptr ;
template <class Ty>
  class auto_ptr_ref ;

    // TEMPLATE OPERATORS
template <class Ty>
  bool operator== (allocator <Ty>& left,
    allocator <Ty>& right);
template <class Ty>
  bool operator!= (allocator <Ty>& left,
    allocator <Ty>& right);


    // TEMPLATE FUNCTIONS
template <class Ty>
  pair <Ty *, ptrdiff_t>
    get_temporary_buffer (ptrdiff_t count);
template <class Ty>
  void return_temporary_buffer (Ty *pbuf);
template <class InIt, class FwdIt>
  FwdIt uninitialized_copy (InIt first, InIt last,
    FwdIt dest);
template <class FwdIt, class Ty>
  void uninitialized_fill (FwdIt first, FwdIt last,
    const Ty& val);
template <class FwdIt, class Size, class Ty>
  void uninitialized_fill_n (FwdIt first, Size count,
    const Ty& val);

  namespace tr1 {
    // TEMPLATE SHARED POINTERS
template <class Ty>
  class shared_ptr ;

template <class Ty1, class Ty2>
  bool operator== (const shared_ptr <Ty1>&,
    const shared_ptr <Ty2>&);
template <class Ty1, class Ty2>
  bool operator!= (const shared_ptr <Ty1>&,
    const shared_ptr <Ty2>&);
template <class Ty1, class Ty2>
  bool operator< (const shared_ptr <Ty1>&,
    const shared_ptr <Ty2>&);
template <class Elem, class Tr, class Ty>
  std :: basic_ostream <Elem, Tr>& operator<< (
    std :: basic_ostream <Elem, Tr>&, const shared_ptr <Ty>&);
template <class Ty>
  void swap (shared_ptr <Ty>&, shared_ptr <Ty>&);
template <class D, class Ty>
  D *get_deleter (const shared_ptr <Ty>&);

    // TEMPLATE WEAK POINTERS
template <class Ty>
  class weak_ptr ;

template <class Ty1, class Ty2>
  bool operator< (const weak_ptr <Ty1>&,
    const weak_ptr <Ty2>&);

template <class Ty>
  void swap (weak_ptr <Ty>&, weak_ptr <Ty>&);

    // UTILITY TEMPLATE CLASSES
template <class Ty>
  class enable_shared_from_this ;
class bad_weak_ptr ;

    // TEMPLATE FUNCTIONS
template <class Ty, class Other>
  shared_ptr <Ty> const_pointer_cast (
    const shared_ptr <Other>&);
template <class Ty, class Other>
  shared_ptr <Ty> dynamic_pointer_cast (
    const shared_ptr <Other>&);
template <class Ty, class Other>
  shared_ptr <Ty> static_pointer_cast (
    const shared_ptr <Other>&);
  } // namespace tr1
}  // namespace std

namespace std {
template <class T, class Ty2>
  struct pair ;

    // TEMPLATE FUNCTIONS
template <class Ty1, class Ty2>
  pair <Ty, Ty2> make_pair (Ty1 val1, Ty2 val2);
template <class Ty1, class Ty2>
  bool operator== (const pair <Ty, Ty2>& left,
    const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
  bool operator!= (const pair <Ty, Ty2>& left,
    const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
  bool operator< (const pair <Ty, Ty2>& left,
    const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
  bool operator> (const pair <Ty1, Ty2>& left,
    const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
  bool operator<= (const pair <Ty1, Ty2>& left,

    const pair <Ty1, Ty2>& right);
template <class Ty1, class Ty2>
  bool operator>= (const pair <Ty1, Ty2>& left,
    const pair <Ty1, Ty2>& right);

namespace rel_ops {
template <class Ty>
  bool operator!= (const Ty& left, const Ty& right);
template <class Ty>
  bool operator<= (const Ty& left, const Ty& right);
template <class Ty>
  bool operator> (const Ty& left, const Ty& right);
template <class Ty>
  bool operator>= (const Ty& left, const Ty& right);
}  // namespace rel ops

  namespace tr1 {
template <int Idx, class T1, class T2>
  RI& get (pair <T1, T2>& pr);
template <int Idx, class T1, class T2>
  const RI& get (const pair <T1, T2>& pr);

template <class T1, class T2>
  class tuple_element <0, pair <T1, T2>>;
template <class T1, class T2>
  class tuple_element <1, pair <T1, T2>>;

template <class T1, class T2>
  class tuple_size <pair <T1, T2>>;
  } // namespace tr1
}  // namespace std