public inbox for gcc-prs@sourceware.org
help / color / mirror / Atom feed
* c++/4147: g++ 3.0.1 internal error with STL
@ 2001-08-27 12:06 sbi
  0 siblings, 0 replies; only message in thread
From: sbi @ 2001-08-27 12:06 UTC (permalink / raw)
  To: gcc-gnats

>Number:         4147
>Category:       c++
>Synopsis:       GCC reports internal error in expand_function_start
>Confidential:   no
>Severity:       critical
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          ice-on-legal-code
>Submitter-Id:   net
>Arrival-Date:   Mon Aug 27 12:06:01 PDT 2001
>Closed-Date:
>Last-Modified:
>Originator:     
>Release:        3.0.1
>Organization:
New Brunswick Computing Services
>Environment:
System: SunOS radiohead.Rutgers.EDU 5.8 Generic_108528-07 sun4u sparc SUNW,Sun-Blade-100
Architecture: sun4

	
host: sparcv9-sun-solaris2.8
build: sparcv9-sun-solaris2.8
target: sparcv9-sun-solaris2.8
configured with: ../configure --prefix=/usr/local/gcc-3.0.1 --enable-shared --enable-threads sparcv9-sun-solaris2.8
>Description:
When compiling test.cpp (included below) g++ -v gives the following output:
Reading specs from /usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/specs
Configured with: ../configure --prefix=/usr/local/gcc-3.0.1 --enable-shared --enable-threads sparcv9-sun-solaris2.8
Thread model: posix
gcc version 3.0.1
 /usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/cpp0 -lang-c++ -D__GNUG__=3 -D__GXX_DEPRECATED -D__EXCEPTIONS -D__GXX_ABI_VERSION=100 -v -D__GNUC__=3 -D__GNUC_MINOR__=0 -D__GNUC_PATCHLEVEL__=1 -Dsparc -Dsun -Dunix -D__svr4__ -D__SVR4 -D__sparc__ -D__sun__ -D__unix__ -D__svr4__ -D__SVR4 -D__sparc -D__sun -D__unix -Asystem=unix -Asystem=svr4 -D__NO_INLINE__ -D__STDC_HOSTED__=1 -D_XOPEN_SOURCE=500 -D_LARGEFILE_SOURCE=1 -D_LARGEFILE64_SOURCE=1 -D__EXTENSIONS__ -D__SIZE_TYPE__=long unsigned int -D__PTRDIFF_TYPE__=long int -D__WCHAR_TYPE__=int -D__WINT_TYPE__=int -D__arch64__ -Acpu=sparc64 -Amachine=sparcv9 -D__sparcv9 test.cpp test.ii
GNU CPP version 3.0.1 (cpplib) (sparc)
ignoring nonexistent directory "/usr/local/gcc-3.0.1/sparcv9-sun-solaris2.8/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/local/gcc-3.0.1/include/g++-v3
 /usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8
 /usr/local/gcc-3.0.1/include/g++-v3/backward
 /usr/local/gcc-3.0.1/include
 /usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include
 /usr/include
End of search list.
 /usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/cc1plus -fpreprocessed test.ii -quiet -dumpbase test.cpp -version -o test.s
GNU CPP version 3.0.1 (cpplib) (sparc)
GNU C++ version 3.0.1 (sparcv9-sun-solaris2.8)
        compiled by GNU C version 2.95.3 20010315 (release).
/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h: In function 
   `_RandomAccessIter std::__unguarded_partition(_RandomAccessIter, 
   _RandomAccessIter, _Tp) [with _RandomAccessIter = 
   std::__normal_iterator<std::pair<int, std::string>*, 
   std::vector<std::pair<int, std::string>, std::allocator<std::pair<int, 
   std::string> > > >, _Tp = std::pair<int, std::string>]':
/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h:1634:   instantiated from `void std::__introsort_loop(_RandomAccessIter, _RandomAccessIter, _Tp*, _Size) [with _RandomAccessIter = std::__normal_iterator<std::pair<int, std::string>*, std::vector<std::pair<int, std::string>, std::allocator<std::pair<int, std::string> > > >, _Tp = std::pair<int, std::string>, _Size = long int]'
/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h:1672:   instantiated from `void std::sort(_RandomAccessIter, _RandomAccessIter) [with _RandomAccessIter = std::__normal_iterator<std::pair<int, std::string>*, std::vector<std::pair<int, std::string>, std::allocator<std::pair<int, std::string> > > >]'
test.cpp:33:   instantiated from here
/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h:1449: Internal compiler 
   error in expand_function_start, at function.c:6424
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL: http://www.gnu.org/software/gcc/bugs.html > for instructions.

>How-To-Repeat:
Here is the preprocessed source:

# 1 "test.cpp"
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/vector" 1 3
# 31 "/usr/local/gcc-3.0.1/include/g++-v3/vector" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 1 3
# 60 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception_defines.h" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 62 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/os_defines.h" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 2 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/limits.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 2 3
# 65 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_pair.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_pair.h" 3
namespace std
{


template <class _T1, class _T2>
struct pair {
  typedef _T1 first_type;
  typedef _T2 second_type;

  _T1 first;
  _T2 second;




  pair() : first(), second() {}




  pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {}


  template <class _U1, class _U2>
  pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
};


template <class _T1, class _T2>
inline bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{
  return __x.first == __y.first && __x.second == __y.second;
}


template <class _T1, class _T2>
inline bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{
  return __x.first < __y.first ||
         (!(__y.first < __x.first) && __x.second < __y.second);
}


template <class _T1, class _T2>
inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return !(__x == __y);
}


template <class _T1, class _T2>
inline bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return __y < __x;
}


template <class _T1, class _T2>
inline bool operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return !(__y < __x);
}


template <class _T1, class _T2>
inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return !(__x < __y);
}
# 139 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_pair.h" 3
template <class _T1, class _T2>


inline pair<_T1, _T2> make_pair(_T1 __x, _T2 __y)



{
  return pair<_T1, _T2>(__x, __y);
}

}
# 67 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3


# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 1 3
# 48 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 50 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 2 3
# 86 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 3
template <bool _Truth> struct _Bool {};
typedef _Bool<true> __true_type;
typedef _Bool<false> __false_type;

template <class _Tp>
struct __type_traits {
   typedef __true_type this_dummy_member_must_be_first;
# 110 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 3
   typedef __false_type has_trivial_default_constructor;
   typedef __false_type has_trivial_copy_constructor;
   typedef __false_type has_trivial_assignment_operator;
   typedef __false_type has_trivial_destructor;
   typedef __false_type is_POD_type;
};




template<> struct __type_traits<bool> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<signed char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<wchar_t> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<short> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned short> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<int> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned int> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};
# 228 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 3
template<> struct __type_traits<float> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<double> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<long double> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template <class _Tp>
struct __type_traits<_Tp*> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};





template <class _Tp> struct _Is_integer {
  typedef __false_type _Integral;
};

template<> struct _Is_integer<bool> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<signed char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<wchar_t> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<short> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned short> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<int> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned int> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<long> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned long> {
  typedef __true_type _Integral;
};
# 325 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 3
template<typename _Tp> struct _Is_normal_iterator {
   typedef __false_type _Normal;
};


namespace std {
   template<typename _Iterator, typename _Container> class __normal_iterator;
};

template<typename _Iterator, typename _Container>
struct _Is_normal_iterator< std::__normal_iterator<_Iterator, _Container> > {
   typedef __true_type _Normal;
};
# 70 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 3
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stddef.h" 1 3 4
# 147 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 199 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 2 3

namespace std
{
  using ::ptrdiff_t;
  using ::size_t;
}
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 2 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 3
# 1 "/usr/include/string.h" 1 3 4
# 16 "/usr/include/string.h" 3 4
#pragma ident "@(#)string.h	1.24	99/08/10 SMI"

# 1 "/usr/include/iso/string_iso.h" 1 3 4
# 28 "/usr/include/iso/string_iso.h" 3 4
#pragma ident "@(#)string_iso.h	1.2	99/11/09 SMI"


# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 13 "/usr/include/sys/feature_tests.h" 3 4
#pragma ident "@(#)feature_tests.h	1.18	99/07/26 SMI"

# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 9 "/usr/include/sys/isa_defs.h" 3 4
#pragma ident "@(#)isa_defs.h	1.20	99/05/04 SMI"
# 158 "/usr/include/sys/isa_defs.h" 3 4
extern "C" {
# 380 "/usr/include/sys/isa_defs.h" 3 4
}
# 16 "/usr/include/sys/feature_tests.h" 2 3 4


extern "C" {
# 181 "/usr/include/sys/feature_tests.h" 3 4
}
# 32 "/usr/include/iso/string_iso.h" 2 3 4


extern "C" {
# 60 "/usr/include/iso/string_iso.h" 3 4
extern int memcmp(const void *, const void *, size_t);
extern void *memcpy(void *, const void *, size_t);
extern void *memmove(void *, const void *, size_t);
extern void *memset(void *, int, size_t);
extern char *strcat(char *, const char *);
extern int strcmp(const char *, const char *);
extern char *strcpy(char *, const char *);
extern int strcoll(const char *, const char *);
extern size_t strcspn(const char *, const char *);
extern char *strerror(int);
extern size_t strlen(const char *);
extern char *strncat(char *, const char *, size_t);
extern int strncmp(const char *, const char *, size_t);
extern char *strncpy(char *, const char *, size_t);
extern size_t strspn(const char *, const char *);
extern char *strtok(char *, const char *);
extern size_t strxfrm(char *, const char *, size_t);
# 112 "/usr/include/iso/string_iso.h" 3 4
extern void *memchr(const void *, int, size_t);
extern char *strchr(const char *, int);
extern char *strpbrk(const char *, const char *);
extern char *strrchr(const char *, int);
extern char *strstr(const char *, const char *);
# 151 "/usr/include/iso/string_iso.h" 3 4
}
# 19 "/usr/include/string.h" 2 3 4
# 51 "/usr/include/string.h" 3 4
extern "C" {






extern char *strtok_r(char *, const char *, char **);




extern void *memccpy(void *, const void *, int, size_t);




extern char *strsignal(int);
extern int ffs(int);
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *, const char *, size_t);
extern size_t strlcpy(char *, const char *, size_t);
extern size_t strlcat(char *, const char *, size_t);





extern char *strdup(const char *);
# 113 "/usr/include/string.h" 3 4
}
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 2 3
# 66 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 3
namespace std
{
  using ::memcpy;
  using ::memmove;
  using ::strcpy;
  using ::strncpy;
  using ::strcat;
  using ::strncat;
  using ::memcmp;
  using ::strcmp;
  using ::strcoll;
  using ::strncmp;
  using ::strxfrm;
  using ::strcspn;
  using ::strspn;
  using ::strtok;
  using ::memset;
  using ::strerror;
  using ::strlen;

  using ::memchr;

  inline void*
  memchr(void* __p, int __c, size_t __n)
  { return memchr(const_cast<const void*>(__p), __c, __n); }

  using ::strchr;

  inline char*
  strchr(char* __s1, int __n)
  { return __builtin_strchr(const_cast<const char*>(__s1), __n); }

  using ::strpbrk;

  inline char*
  strpbrk(char* __s1, const char* __s2)
  { return __builtin_strpbrk(const_cast<const char*>(__s1), __s2); }

  using ::strrchr;

  inline char*
  strrchr(char* __s1, int __n)
  { return __builtin_strrchr(const_cast<const char*>(__s1), __n); }

  using ::strstr;

  inline char*
  strstr(char* __s1, const char* __s2)
  { return __builtin_strstr(const_cast<const char*>(__s1), __s2); }
}
# 72 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_climits.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_climits.h" 3
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/limits.h" 1 3 4
# 11 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/limits.h" 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 1 3 4
# 25 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 3 4
#pragma ident "@(#)limits.h	1.51	99/10/08 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 28 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 2 3 4
# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 29 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 2 3 4
# 1 "/usr/include/iso/limits_iso.h" 1 3 4
# 28 "/usr/include/iso/limits_iso.h" 3 4
#pragma ident "@(#)limits_iso.h	1.1	99/08/09 SMI"


extern "C" {
# 75 "/usr/include/iso/limits_iso.h" 3 4
}
# 30 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 2 3 4
# 41 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 3 4
# 1 "/usr/include/sys/int_limits.h" 1 3 4
# 9 "/usr/include/sys/int_limits.h" 3 4
#pragma ident "@(#)int_limits.h	1.6	99/08/06 SMI"
# 44 "/usr/include/sys/int_limits.h" 3 4
# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 45 "/usr/include/sys/int_limits.h" 2 3 4


extern "C" {
# 162 "/usr/include/sys/int_limits.h" 3 4
}
# 42 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 2 3 4



extern "C" {
# 243 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 3 4
typedef long clock_t;


extern long _sysconf(int);
# 268 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 3 4
# 1 "/usr/include/sys/unistd.h" 1 3 4
# 25 "/usr/include/sys/unistd.h" 3 4
#pragma ident "@(#)unistd.h	1.37	98/10/28 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 28 "/usr/include/sys/unistd.h" 2 3 4


extern "C" {
# 265 "/usr/include/sys/unistd.h" 3 4
}
# 269 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 2 3 4
# 279 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 3 4
extern long _sysconf(int);
# 289 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/syslimits.h" 3 4
}
# 12 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/limits.h" 2 3 4
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_climits.h" 2 3
# 73 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 2 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 16 "/usr/include/stdlib.h" 3 4
#pragma ident "@(#)stdlib.h	1.47	99/11/03 SMI"

# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/stdlib_iso.h" 1 3 4
# 37 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/stdlib_iso.h" 3 4
#pragma ident "@(#)stdlib_iso.h	1.2	99/12/21 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 40 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/stdlib_iso.h" 2 3 4


extern "C" {



extern unsigned char __ctype[];
# 57 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/stdlib_iso.h" 3 4
typedef struct {
        int quot;
        int rem;
} div_t;

typedef struct {
        long quot;
        long rem;
} ldiv_t;
# 103 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/stdlib_iso.h" 3 4
extern void abort(void);
extern int abs(int);
extern int atexit(void (*)(void));
extern double atof(const char *);
extern int atoi(const char *);
extern long int atol(const char *);
extern void *bsearch(const void *, const void *, size_t, size_t,
        int (*)(const void *, const void *));
extern void *calloc(size_t, size_t);
extern div_t div(int, int);
extern void exit(int);
extern void free(void *);
extern char *getenv(const char *);
extern long int labs(long);
extern ldiv_t ldiv(long, long);
extern void *malloc(size_t);
extern int mblen(const char *, size_t);
extern size_t mbstowcs(wchar_t *, const char *, size_t);
extern int mbtowc(wchar_t *, const char *, size_t);
extern void qsort(void *, size_t, size_t,
        int (*)(const void *, const void *));
extern int rand(void);
extern void *realloc(void *, size_t);
extern void srand(unsigned int);
extern double strtod(const char *, char **);
extern long int strtol(const char *, char **, int);
extern unsigned long int strtoul(const char *, char **, int);
extern int system(const char *);
extern int wctomb(char *, wchar_t);
extern size_t wcstombs(char *, const wchar_t *, size_t);
# 172 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/stdlib_iso.h" 3 4
}
# 19 "/usr/include/stdlib.h" 2 3 4



# 1 "/usr/include/sys/wait.h" 1 3 4
# 16 "/usr/include/sys/wait.h" 3 4
#pragma ident "@(#)wait.h	1.21	97/04/08 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 19 "/usr/include/sys/wait.h" 2 3 4

# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 25 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
#pragma ident "@(#)types.h	1.66	00/02/14 SMI"

# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 28 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 2 3 4
# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 29 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 2 3 4




# 1 "/usr/include/sys/machtypes.h" 1 3 4
# 16 "/usr/include/sys/machtypes.h" 3 4
#pragma ident "@(#)machtypes.h	1.13	99/05/04 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 19 "/usr/include/sys/machtypes.h" 2 3 4


extern "C" {
# 33 "/usr/include/sys/machtypes.h" 3 4
typedef struct _label_t { long val[2]; } label_t;



typedef unsigned char lock_t;


}
# 34 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 2 3 4
# 45 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
# 1 "/usr/include/sys/int_types.h" 1 3 4
# 9 "/usr/include/sys/int_types.h" 3 4
#pragma ident "@(#)int_types.h	1.6	97/08/20 SMI"
# 42 "/usr/include/sys/int_types.h" 3 4
# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 43 "/usr/include/sys/int_types.h" 2 3 4


extern "C" {
# 62 "/usr/include/sys/int_types.h" 3 4
typedef char int8_t;





typedef short int16_t;
typedef int int32_t;

typedef long int64_t;






typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;

typedef unsigned long uint64_t;
# 94 "/usr/include/sys/int_types.h" 3 4
typedef int64_t intmax_t;
typedef uint64_t uintmax_t;
# 107 "/usr/include/sys/int_types.h" 3 4
typedef long intptr_t;
typedef unsigned long uintptr_t;
# 119 "/usr/include/sys/int_types.h" 3 4
typedef char int_least8_t;





typedef short int_least16_t;
typedef int int_least32_t;

typedef long int_least64_t;






typedef unsigned char uint_least8_t;
typedef unsigned short uint_least16_t;
typedef unsigned int uint_least32_t;

typedef unsigned long uint_least64_t;







}
# 46 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 2 3 4







extern "C" {
# 62 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef long long longlong_t;
typedef unsigned long long u_longlong_t;
# 82 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef int32_t t_scalar_t;
typedef uint32_t t_uscalar_t;
# 92 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef unsigned char uchar_t;
typedef unsigned short ushort_t;
typedef unsigned int uint_t;
typedef unsigned long ulong_t;

typedef char *caddr_t;
typedef long daddr_t;
typedef short cnt_t;
# 127 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef ulong_t pfn_t;
typedef ulong_t pgcnt_t;
typedef long spgcnt_t;

typedef uchar_t use_t;
typedef short sysid_t;
typedef short index_t;
typedef void *timeout_id_t;
typedef void *bufcall_id_t;
# 149 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef long off_t;






typedef off_t off64_t;
# 165 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef ulong_t ino_t;
typedef long blkcnt_t;
typedef ulong_t fsblkcnt_t;
typedef ulong_t fsfilcnt_t;
# 178 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef ino_t ino64_t;
typedef blkcnt_t blkcnt64_t;
typedef fsblkcnt_t fsblkcnt64_t;
typedef fsfilcnt_t fsfilcnt64_t;
# 191 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef int blksize_t;





typedef enum { _B_FALSE, _B_TRUE } boolean_t;
# 210 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef int64_t pad64_t;
typedef uint64_t upad64_t;
# 223 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef longlong_t offset_t;
typedef u_longlong_t u_offset_t;
typedef u_longlong_t len_t;
typedef longlong_t diskaddr_t;
# 244 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef union {
        offset_t _f;
        struct {
                int32_t _u;
                int32_t _l;
        } _p;
} lloff_t;
# 264 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef union {
        diskaddr_t _f;
        struct {
                int32_t _u;
                int32_t _l;
        } _p;
} lldaddr_t;


typedef uint_t k_fltset_t;
# 285 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef int id_t;
# 294 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef uint_t useconds_t;



typedef long suseconds_t;






typedef uint_t major_t;
typedef uint_t minor_t;
# 315 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef short pri_t;
# 328 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef ushort_t o_mode_t;
typedef short o_dev_t;
typedef ushort_t o_uid_t;
typedef o_uid_t o_gid_t;
typedef short o_nlink_t;
typedef short o_pid_t;
typedef ushort_t o_ino_t;





typedef int key_t;

typedef uint_t mode_t;







typedef int uid_t;





typedef uid_t gid_t;

typedef id_t taskid_t;
typedef id_t projid_t;






typedef unsigned int pthread_t;
typedef unsigned int pthread_key_t;

typedef struct _pthread_mutex {
        struct {
                uint16_t __pthread_mutex_flag1;
                uint8_t __pthread_mutex_flag2;
                uint8_t __pthread_mutex_ceiling;
                uint32_t __pthread_mutex_type;
        } __pthread_mutex_flags;
        union {
                struct {
                        uint8_t __pthread_mutex_pad[8];
                } __pthread_mutex_lock64;
                upad64_t __pthread_mutex_owner64;
        } __pthread_mutex_lock;
        upad64_t __pthread_mutex_data;
} pthread_mutex_t;

typedef struct _pthread_cond {
        struct {
                uint8_t __pthread_cond_flag[4];
                uint32_t __pthread_cond_type;
        } __pthread_cond_flags;
        upad64_t __pthread_cond_data;
} pthread_cond_t;




typedef struct _pthread_rwlock {
        int32_t __pthread_rwlock_readers;
        uint16_t __pthread_rwlock_type;
        uint16_t __pthread_rwlock_magic;
        upad64_t __pthread_rwlock_pad1[3];
        upad64_t __pthread_rwlock_pad2[2];
        upad64_t __pthread_rwlock_pad3[2];
} pthread_rwlock_t;




typedef struct _pthread_attr {
        void *__pthread_attrp;
} pthread_attr_t;





typedef struct _pthread_mutexattr {
        void *__pthread_mutexattrp;
} pthread_mutexattr_t;





typedef struct _pthread_condattr {
        void *__pthread_condattrp;
} pthread_condattr_t;




typedef struct _once {
        upad64_t __pthread_once_pad[4];
} pthread_once_t;





typedef struct _pthread_rwlockattr {
        void *__pthread_rwlockattrp;
} pthread_rwlockattr_t;

typedef ulong_t dev_t;


typedef uint_t nlink_t;
typedef int pid_t;
# 473 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef long ssize_t;







typedef long time_t;
# 491 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef int clockid_t;




typedef int timer_t;






typedef unsigned char unchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
# 557 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
typedef struct _quad { int val[2]; } quad_t;
typedef quad_t quad;






# 1 "/usr/include/sys/select.h" 1 3 4
# 12 "/usr/include/sys/select.h" 3 4
#pragma ident "@(#)select.h	1.16	98/04/27 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 15 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/sys/time.h" 1 3 4
# 22 "/usr/include/sys/time.h" 3 4
#pragma ident "@(#)time.h	2.66	01/01/17 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 25 "/usr/include/sys/time.h" 2 3 4







extern "C" {
# 49 "/usr/include/sys/time.h" 3 4
struct timeval {
        time_t tv_sec;
        suseconds_t tv_usec;
};
# 82 "/usr/include/sys/time.h" 3 4
struct timezone {
        int tz_minuteswest;
        int tz_dsttime;
};





}
# 100 "/usr/include/sys/time.h" 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 101 "/usr/include/sys/time.h" 2 3 4



extern "C" {
# 155 "/usr/include/sys/time.h" 3 4
struct itimerval {
        struct timeval it_interval;
        struct timeval it_value;
};
# 203 "/usr/include/sys/time.h" 3 4
typedef longlong_t hrtime_t;
# 320 "/usr/include/sys/time.h" 3 4
int adjtime(struct timeval *, struct timeval *);
# 331 "/usr/include/sys/time.h" 3 4
int getitimer(int, struct itimerval *);
int utimes(const char *, const struct timeval *);

int setitimer(int, const struct itimerval *, struct itimerval *);
# 369 "/usr/include/sys/time.h" 3 4
int settimeofday(struct timeval *, void *);

hrtime_t gethrtime(void);
hrtime_t gethrvtime(void);
# 389 "/usr/include/sys/time.h" 3 4
int gettimeofday(struct timeval *, void *);
# 410 "/usr/include/sys/time.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 16 "/usr/include/time.h" 3 4
#pragma ident "@(#)time.h	1.39	99/08/10 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 19 "/usr/include/time.h" 2 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 20 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/iso/time_iso.h" 1 3 4
# 28 "/usr/include/iso/time_iso.h" 3 4
#pragma ident "@(#)time_iso.h	1.1	99/08/09 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 31 "/usr/include/iso/time_iso.h" 2 3 4


extern "C" {
# 69 "/usr/include/iso/time_iso.h" 3 4
struct tm {
        int tm_sec;
        int tm_min;
        int tm_hour;
        int tm_mday;
        int tm_mon;
        int tm_year;
        int tm_wday;
        int tm_yday;
        int tm_isdst;
};




extern char *asctime(const struct tm *);
extern clock_t clock(void);
extern char *ctime(const time_t *);
extern double difftime(time_t, time_t);
extern struct tm *gmtime(const time_t *);
extern struct tm *localtime(const time_t *);
extern time_t mktime(struct tm *);
extern time_t time(time_t *);
extern size_t strftime(char *, size_t, const char *, const struct tm *);
# 113 "/usr/include/iso/time_iso.h" 3 4
}
# 21 "/usr/include/time.h" 2 3 4
# 43 "/usr/include/time.h" 3 4
extern "C" {
# 60 "/usr/include/time.h" 3 4
extern struct tm *gmtime_r(const time_t *, struct tm *);
extern struct tm *localtime_r(const time_t *, struct tm *);





extern char *strptime(const char *, const char *, struct tm *);
# 83 "/usr/include/time.h" 3 4
# 1 "/usr/include/sys/time_impl.h" 1 3 4
# 15 "/usr/include/sys/time_impl.h" 3 4
#pragma ident "@(#)time_impl.h	1.5	99/10/05 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 18 "/usr/include/sys/time_impl.h" 2 3 4


extern "C" {
# 36 "/usr/include/sys/time_impl.h" 3 4
typedef struct timespec {
        time_t tv_sec;
        long tv_nsec;
} timespec_t;
# 60 "/usr/include/sys/time_impl.h" 3 4
typedef struct timespec timestruc_t;
# 79 "/usr/include/sys/time_impl.h" 3 4
typedef struct itimerspec {
        struct timespec it_interval;
        struct timespec it_value;
} itimerspec_t;
# 136 "/usr/include/sys/time_impl.h" 3 4
}
# 84 "/usr/include/time.h" 2 3 4
# 98 "/usr/include/time.h" 3 4
union sigval {
        int sival_int;
        void *sival_ptr;
};




struct sigevent {
        int sigev_notify;
        int sigev_signo;
        union sigval sigev_value;
        void (*sigev_notify_function)(union sigval);
        pthread_attr_t *sigev_notify_attributes;
        int __sigev_pad2;
};


extern int clock_getres(clockid_t, struct timespec *);
extern int clock_gettime(clockid_t, struct timespec *);
extern int clock_settime(clockid_t, const struct timespec *);
extern int timer_create(clockid_t, struct sigevent *, timer_t *);
extern int timer_delete(timer_t);
extern int timer_getoverrun(timer_t);
extern int timer_gettime(timer_t, struct itimerspec *);
extern int timer_settime(timer_t, int, const struct itimerspec *,
                struct itimerspec *);
extern int nanosleep(const struct timespec *, struct timespec *);




extern void tzset(void);

extern char *tzname[2];
# 142 "/usr/include/time.h" 3 4
extern long timezone;
extern int daylight;
# 156 "/usr/include/time.h" 3 4
extern struct tm *getdate(const char *);






extern int getdate_err;
# 256 "/usr/include/time.h" 3 4
static char *
asctime_r(const struct tm *__tm, char *__buf)
{
        extern char *__posix_asctime_r(const struct tm *, char *);
        return (__posix_asctime_r(__tm, __buf));
}
static char *
ctime_r(const time_t *__time, char *__buf)
{
        extern char *__posix_ctime_r(const time_t *, char *);
        return (__posix_ctime_r(__time, __buf));
}
# 318 "/usr/include/time.h" 3 4
}
# 411 "/usr/include/sys/time.h" 2 3 4
# 423 "/usr/include/sys/time.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 424 "/usr/include/sys/time.h" 2 3 4





}
# 18 "/usr/include/sys/select.h" 2 3 4



extern "C" {
# 45 "/usr/include/sys/select.h" 3 4
typedef long fd_mask;

typedef long fds_mask;
# 73 "/usr/include/sys/select.h" 3 4
typedef struct fd_set {



        long fds_bits[(((65536)+(((sizeof (fds_mask) * 8))-1))/((sizeof (fds_mask) * 8)))];
} fd_set;
# 97 "/usr/include/sys/select.h" 3 4
extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *);






}
# 570 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 2 3 4
# 586 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 3 4
}
# 21 "/usr/include/sys/wait.h" 2 3 4



# 1 "/usr/include/sys/resource.h" 1 3 4
# 16 "/usr/include/sys/resource.h" 3 4
#pragma ident "@(#)resource.h	1.25	98/06/30 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 19 "/usr/include/sys/resource.h" 2 3 4

# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 21 "/usr/include/sys/resource.h" 2 3 4
# 1 "/usr/include/sys/time.h" 1 3 4
# 22 "/usr/include/sys/resource.h" 2 3 4


extern "C" {
# 53 "/usr/include/sys/resource.h" 3 4
typedef unsigned long rlim_t;
# 102 "/usr/include/sys/resource.h" 3 4
struct rlimit {
        rlim_t rlim_cur;
        rlim_t rlim_max;
};




typedef u_longlong_t rlim64_t;





struct rlimit64 {
        rlim64_t rlim_cur;
        rlim64_t rlim_max;
};
# 143 "/usr/include/sys/resource.h" 3 4
struct rusage {
        struct timeval ru_utime;
        struct timeval ru_stime;
        long ru_maxrss;
        long ru_ixrss;
        long ru_idrss;
        long ru_isrss;
        long ru_minflt;
        long ru_majflt;
        long ru_nswap;
        long ru_inblock;
        long ru_oublock;
        long ru_msgsnd;
        long ru_msgrcv;
        long ru_nsignals;
        long ru_nvcsw;
        long ru_nivcsw;
};
# 193 "/usr/include/sys/resource.h" 3 4
extern int setrlimit(int, const struct rlimit *);
extern int getrlimit(int, struct rlimit *);
# 203 "/usr/include/sys/resource.h" 3 4
extern int getpriority(int, id_t);
extern int setpriority(int, id_t, int);
extern int getrusage(int, struct rusage *);
# 228 "/usr/include/sys/resource.h" 3 4
}
# 25 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/siginfo.h" 1 3 4
# 16 "/usr/include/sys/siginfo.h" 3 4
#pragma ident "@(#)siginfo.h	1.54	98/03/27 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 19 "/usr/include/sys/siginfo.h" 2 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 20 "/usr/include/sys/siginfo.h" 2 3 4


extern "C" {
# 126 "/usr/include/sys/siginfo.h" 3 4
# 1 "/usr/include/sys/machsig.h" 1 3 4
# 16 "/usr/include/sys/machsig.h" 3 4
#pragma ident "@(#)machsig.h	1.15	99/08/15 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 19 "/usr/include/sys/machsig.h" 2 3 4


extern "C" {
# 107 "/usr/include/sys/machsig.h" 3 4
}
# 127 "/usr/include/sys/siginfo.h" 2 3 4
# 206 "/usr/include/sys/siginfo.h" 3 4
# 1 "/usr/include/sys/time_impl.h" 1 3 4
# 207 "/usr/include/sys/siginfo.h" 2 3 4
# 217 "/usr/include/sys/siginfo.h" 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 218 "/usr/include/sys/siginfo.h" 2 3 4



typedef struct siginfo {



        int si_signo;
        int si_code;
        int si_errno;

        int si_pad;

        union {

                int __pad[((256 / sizeof (int)) - 4)];

                struct {
                        pid_t __pid;
                        union {
                                struct {
                                        uid_t __uid;


                                        union sigval __value;



                                } __kill;
                                struct {
                                        clock_t __utime;
                                        int __status;
                                        clock_t __stime;
                                } __cld;
                        } __pdata;
                } __proc;

                struct {
                        void *__addr;
                        int __trapno;
                        caddr_t __pc;
                } __fault;

                struct {

                        int __fd;
                        long __band;
                } __file;

                struct {
                        caddr_t __faddr;


                        timestruc_t __tstamp;



                        short __syscall;
                        char __nsysarg;
                        char __fault;
                        long __sysarg[8];
                        int __mstate[10];
                } __prof;

        } __data;

} siginfo_t;
# 354 "/usr/include/sys/siginfo.h" 3 4
typedef struct k_siginfo {
        int si_signo;
        int si_code;
        int si_errno;

        int si_pad;

        union {
                struct {
                        pid_t __pid;
                        union {
                                struct {
                                        uid_t __uid;
                                        union sigval __value;
                                } __kill;
                                struct {
                                        clock_t __utime;
                                        int __status;
                                        clock_t __stime;
                                } __cld;
                        } __pdata;
                } __proc;

                struct {
                        void *__addr;
                        int __trapno;
                        caddr_t __pc;
                } __fault;

                struct {

                        int __fd;
                        long __band;
                } __file;

                struct {
                        caddr_t __faddr;



                        timestruc_t __tstamp;



                        short __syscall;
                        char __nsysarg;
                        char __fault;



                } __prof;

        } __data;

} k_siginfo_t;

typedef struct sigqueue {
        struct sigqueue *sq_next;
        k_siginfo_t sq_info;
        void (*sq_func)(struct sigqueue *);
        void *sq_backptr;

} sigqueue_t;
# 454 "/usr/include/sys/siginfo.h" 3 4
}
# 26 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/procset.h" 1 3 4
# 16 "/usr/include/sys/procset.h" 3 4
#pragma ident "@(#)procset.h	1.20	00/02/14 SMI"


extern "C" {


# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 23 "/usr/include/sys/procset.h" 2 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 24 "/usr/include/sys/procset.h" 2 3 4
# 41 "/usr/include/sys/procset.h" 3 4
typedef enum

        idtype

                {
        P_PID,
        P_PPID,
        P_PGID,

        P_SID,
        P_CID,
        P_UID,
        P_GID,
        P_ALL,
        P_LWPID,
        P_TASKID,
        P_PROJID
} idtype_t;
# 67 "/usr/include/sys/procset.h" 3 4
typedef enum idop {
        POP_DIFF,


        POP_AND,


        POP_OR,


        POP_XOR


} idop_t;







typedef struct procset {
        idop_t p_op;




        idtype_t p_lidtype;


        id_t p_lid;

        idtype_t p_ridtype;


        id_t p_rid;
} procset_t;
# 132 "/usr/include/sys/procset.h" 3 4
}
# 27 "/usr/include/sys/wait.h" 2 3 4



extern "C" {
# 86 "/usr/include/sys/wait.h" 3 4
extern pid_t wait(int *);
extern pid_t waitpid(pid_t, int *, int);


extern int waitid(idtype_t, id_t, siginfo_t *, int);
extern pid_t wait3(int *, int, struct rusage *);




extern pid_t wait4(pid_t, int *, int, struct rusage *);
# 118 "/usr/include/sys/wait.h" 3 4
}
# 23 "/usr/include/stdlib.h" 2 3 4
# 64 "/usr/include/stdlib.h" 3 4
extern "C" {



typedef struct {
        long long quot;
        long long rem;
} lldiv_t;
# 109 "/usr/include/stdlib.h" 3 4
extern int rand_r(unsigned int *);


extern void _exithandle(void);




extern double drand48(void);
extern double erand48(unsigned short *);
extern long jrand48(unsigned short *);
extern void lcong48(unsigned short *);
extern long lrand48(void);
extern long mrand48(void);
extern long nrand48(unsigned short *);
extern unsigned short *seed48(unsigned short *);
extern void srand48(long);
extern int putenv(char *);
extern void setkey(const char *);
# 150 "/usr/include/stdlib.h" 3 4
extern int mkstemp(char *);
# 161 "/usr/include/stdlib.h" 3 4
extern long a64l(const char *);
extern char *ecvt(double, int, int *, int *);
extern char *fcvt(double, int, int *, int *);
extern char *gcvt(double, int, char *);
extern int getsubopt(char **, char *const *, char **);
extern int grantpt(int);
extern char *initstate(unsigned, char *, size_t);
extern char *l64a(long);
extern char *mktemp(char *);
extern char *ptsname(int);
extern long random(void);
extern char *realpath(const char *, char *);
extern char *setstate(const char *);
extern void srandom(unsigned);
extern int ttyslot(void);
extern int unlockpt(int);
extern void *valloc(size_t);




extern int dup2(int, int);
extern char *qecvt(long double, int, int *, int *);
extern char *qfcvt(long double, int, int *, int *);
extern char *qgcvt(long double, int, char *);
extern char *getcwd(char *, size_t);
extern const char *getexecname(void);
extern char *getlogin(void);
extern int getopt(int, char *const *, const char *);
extern char *optarg;
extern int optind, opterr, optopt;
extern char *getpass(const char *);
extern char *getpassphrase(const char *);
extern int getpw(uid_t, char *);
extern int isatty(int);
extern void *memalign(size_t, size_t);
extern char *ttyname(int);


extern long long atoll(const char *);
extern long long llabs(long long);
extern lldiv_t lldiv(long long, long long);
extern char *lltostr(long long, char *);
extern long long strtoll(const char *, char **, int);
extern unsigned long long strtoull(const char *, char **, int);
extern char *ulltostr(unsigned long long, char *);
# 308 "/usr/include/stdlib.h" 3 4
}
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 2 3
# 73 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 3
namespace std
{
  using ::div_t;
  using ::ldiv_t;

  using ::abort;
  using ::abs;
  using ::atexit;
  using ::atof;
  using ::atoi;
  using ::atol;
  using ::bsearch;
  using ::calloc;
  using ::div;
  using ::exit;
  using ::free;
  using ::getenv;
  using ::labs;
  using ::ldiv;
  using ::malloc;
  using ::mblen;
  using ::mbstowcs;
  using ::mbtowc;
  using ::qsort;
  using ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;
  using ::wcstombs;
  using ::wctomb;

  inline long
  abs(long __i) { return labs(__i); }

  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }
}
# 74 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 75 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/new" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/new" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/cstddef" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/new" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception" 1 3
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/exception" 3
extern "C++" {

namespace std
{






  class exception
  {
  public:
    exception() throw() { }
    virtual ~exception() throw();


    virtual const char* what() const throw();
  };



  class bad_exception : public exception
  {
  public:
    bad_exception() throw() { }
    virtual ~bad_exception() throw();
  };


  typedef void (*terminate_handler) ();

  typedef void (*unexpected_handler) ();


  terminate_handler set_terminate(terminate_handler) throw();


  void terminate() __attribute__ ((__noreturn__));


  unexpected_handler set_unexpected(unexpected_handler) throw();


  void unexpected() __attribute__ ((__noreturn__));
# 95 "/usr/local/gcc-3.0.1/include/g++-v3/exception" 3
  bool uncaught_exception() throw();
}

}
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/new" 2 3

extern "C++" {

namespace std
{


  class bad_alloc : public exception
  {
  public:
    bad_alloc() throw() { }
    virtual ~bad_alloc() throw();
  };

  struct nothrow_t { };
  extern const nothrow_t nothrow;


  typedef void (*new_handler)();

  new_handler set_new_handler(new_handler);
}
# 76 "/usr/local/gcc-3.0.1/include/g++-v3/new" 3
void *operator new(std::size_t) throw (std::bad_alloc);
void *operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void *) throw();
void operator delete[](void *) throw();
void *operator new(std::size_t, const std::nothrow_t&) throw();
void *operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void *, const std::nothrow_t&) throw();
void operator delete[](void *, const std::nothrow_t&) throw();


inline void *operator new(std::size_t, void *place) throw() { return place; }
inline void *operator new[](std::size_t, void *place) throw() { return place; }

}
# 76 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stringfwd.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stringfwd.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stringfwd.h" 2 3

namespace std
{
  template<class _CharT>
    struct char_traits;

  template<> struct char_traits<char>;




  template<typename _Alloc>
    class allocator;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_string;

  typedef basic_string<char> string;



}
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/fpos.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/fpos.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++io.h" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++io.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/cstdio" 1 3
# 31 "/usr/local/gcc-3.0.1/include/g++-v3/cstdio" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 2 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 3
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 1 3 4
# 14 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdarg.h" 1 3 4
# 43 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 15 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 2 3 4
# 34 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
#pragma ident "@(#)stdio.h	1.78	99/12/08 SMI"

# 1 "/usr/include/iso/stdio_iso.h" 1 3 4
# 32 "/usr/include/iso/stdio_iso.h" 3 4
#pragma ident "@(#)stdio_iso.h	1.2	99/10/25 SMI"


# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 36 "/usr/include/iso/stdio_iso.h" 2 3 4
# 1 "/usr/include/sys/va_list.h" 1 3 4
# 9 "/usr/include/sys/va_list.h" 3 4
#pragma ident "@(#)va_list.h	1.12	99/05/04 SMI"
# 22 "/usr/include/sys/va_list.h" 3 4
extern "C" {



typedef void *__va_list;





}
# 37 "/usr/include/iso/stdio_iso.h" 2 3 4
# 1 "/usr/include/stdio_tag.h" 1 3 4
# 9 "/usr/include/stdio_tag.h" 3 4
#pragma ident "@(#)stdio_tag.h	1.3	98/04/20 SMI"


extern "C" {
# 21 "/usr/include/stdio_tag.h" 3 4
typedef struct FILE __FILE;



}
# 38 "/usr/include/iso/stdio_iso.h" 2 3 4
# 1 "/usr/include/stdio_impl.h" 1 3 4
# 9 "/usr/include/stdio_impl.h" 3 4
#pragma ident "@(#)stdio_impl.h	1.8	99/06/10 SMI"

# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 12 "/usr/include/stdio_impl.h" 2 3 4


extern "C" {
# 30 "/usr/include/stdio_impl.h" 3 4
struct FILE {
        long __pad[16];
};
# 58 "/usr/include/stdio_impl.h" 3 4
}
# 39 "/usr/include/iso/stdio_iso.h" 2 3 4
# 49 "/usr/include/iso/stdio_iso.h" 3 4
extern "C" {
# 75 "/usr/include/iso/stdio_iso.h" 3 4
typedef __FILE FILE;
# 88 "/usr/include/iso/stdio_iso.h" 3 4
typedef long fpos_t;
# 147 "/usr/include/iso/stdio_iso.h" 3 4
extern __FILE __iob[20];
# 164 "/usr/include/iso/stdio_iso.h" 3 4
extern int remove(const char *);
extern int rename(const char *, const char *);
extern FILE *tmpfile(void);
extern char *tmpnam(char *);
extern int fclose(FILE *);
extern int fflush(FILE *);
extern FILE *fopen(const char *, const char *);
extern FILE *freopen(const char *, const char *, FILE *);
extern void setbuf(FILE *, char *);
extern int setvbuf(FILE *, char *, int, size_t);

extern int fprintf(FILE *, const char *, ...);

extern int fscanf(FILE *, const char *, ...);

extern int printf(const char *, ...);

extern int scanf(const char *, ...);

extern int sprintf(char *, const char *, ...);

extern int sscanf(const char *, const char *, ...);
extern int vfprintf(FILE *, const char *, __va_list);
extern int vprintf(const char *, __va_list);
extern int vsprintf(char *, const char *, __va_list);
extern int fgetc(FILE *);
extern char *fgets(char *, int, FILE *);
extern int fputc(int, FILE *);
extern int fputs(const char *, FILE *);


extern int getc(FILE *);
extern int putc(int, FILE *);



extern int getchar(void);
extern int putchar(int);

extern char *gets(char *);
extern int puts(const char *);
extern int ungetc(int, FILE *);
extern size_t fread(void *, size_t, size_t, FILE *);
extern size_t fwrite(const void *, size_t, size_t, FILE *);
extern int fgetpos(FILE *, fpos_t *);
extern int fseek(FILE *, long, int);
extern int fsetpos(FILE *, const fpos_t *);
extern long ftell(FILE *);
extern void rewind(FILE *);


extern void clearerr(FILE *);
extern int feof(FILE *);
extern int ferror(FILE *);

extern void perror(const char *);
# 336 "/usr/include/iso/stdio_iso.h" 3 4
}
# 37 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 2 3 4
# 98 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
extern "C" {
# 121 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
typedef fpos_t fpos64_t;
# 134 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
typedef __va_list __not_va_list__;
# 151 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
extern unsigned char _sibuf[], _sobuf[];
# 225 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
extern char *tmpnam_r(char *);



extern void setbuffer(FILE *, char *, size_t);
extern int setlinebuf(FILE *);





extern int snprintf(char *, size_t, const char *, ...);




extern int vsnprintf(char *, size_t, const char *, __gnuc_va_list);
# 250 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
extern FILE *fdopen(int, const char *);
extern char *ctermid(char *);
extern int fileno(FILE *);
# 261 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
extern void flockfile(FILE *);
extern int ftrylockfile(FILE *);
extern void funlockfile(FILE *);
extern int getc_unlocked(FILE *);
extern int getchar_unlocked(void);
extern int putc_unlocked(int, FILE *);
extern int putchar_unlocked(int);
# 276 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
extern FILE *popen(const char *, const char *);
extern char *cuserid(char *);
extern char *tempnam(const char *, const char *);
extern int getopt(int, char *const *, const char *);



extern char *optarg;
extern int optind, opterr, optopt;
extern int getw(FILE *);
extern int putw(int, FILE *);
extern int pclose(FILE *);







extern int fseeko(FILE *, off_t, int);
extern off_t ftello(FILE *);
# 412 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 3 4
}
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 2 3
# 86 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 3
namespace std
{
  using ::FILE;
  using ::fpos_t;

  using ::clearerr;
  using ::fclose;
  using ::feof;
  using ::ferror;
  using ::fflush;
  using ::fgetc;
  using ::fgetpos;
  using ::fgets;
  using ::fopen;
  using ::fprintf;
  using ::fputc;
  using ::fputs;
  using ::fread;
  using ::freopen;
  using ::fscanf;
  using ::fseek;
  using ::fsetpos;
  using ::ftell;
  using ::fwrite;
  using ::getc;
  using ::getchar;
  using ::gets;
  using ::perror;
  using ::printf;
  using ::putc;
  using ::putchar;
  using ::puts;
  using ::remove;
  using ::rename;
  using ::rewind;
  using ::scanf;
  using ::setbuf;
  using ::setvbuf;
  using ::sprintf;
  using ::sscanf;
  using ::tmpfile;
  using ::tmpnam;
  using ::ungetc;
  using ::vfprintf;
  using ::vprintf;
  using ::vsprintf;
}
# 32 "/usr/local/gcc-3.0.1/include/g++-v3/cstdio" 2 3
# 36 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++io.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/cstddef" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++io.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr.h" 1 3
# 98 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr-default.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr-default.h" 3
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 1 3 4
# 18 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 3 4
#pragma ident "@(#)pthread.h	1.28	99/11/15 SMI"


# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 22 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 23 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 2 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 11 "/usr/include/sched.h" 3 4
#pragma ident "@(#)sched.h	1.9	98/01/16 SMI"

# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/sys/types.h" 1 3 4
# 14 "/usr/include/sched.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 15 "/usr/include/sched.h" 2 3 4


extern "C" {


struct sched_param {
        int sched_priority;
        int sched_nicelim;
        int sched_nice;
        int sched_pad[6];



};
# 44 "/usr/include/sched.h" 3 4
int sched_getparam(pid_t pid, struct sched_param *param);
int sched_setparam(pid_t pid, const struct sched_param *param);
int sched_getscheduler(pid_t pid);
int sched_setscheduler(pid_t pid, int policy,
                const struct sched_param *param);
int sched_yield(void);
int sched_get_priority_max(int policy);
int sched_get_priority_min(int policy);
int sched_rr_get_interval(pid_t pid, struct timespec *interval);
# 65 "/usr/include/sched.h" 3 4
}
# 24 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 2 3 4



extern "C" {
# 125 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 3 4
typedef struct _cleanup {
        uintptr_t pthread_cleanup_pad[4];
} _cleanup_t;



void __pthread_cleanup_push(void (*routine)(void *), void *args,
                                        caddr_t fp, _cleanup_t *info);
void __pthread_cleanup_pop(int ex, _cleanup_t *info);
caddr_t _getfp(void);
# 159 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 3 4
extern int pthread_attr_init(pthread_attr_t *);
extern int pthread_attr_destroy(pthread_attr_t *);
extern int pthread_attr_setstacksize(pthread_attr_t *, size_t);
extern int pthread_attr_getstacksize(const pthread_attr_t *, size_t *);
extern int pthread_attr_setstackaddr(pthread_attr_t *, void *);
extern int pthread_attr_getstackaddr(const pthread_attr_t *, void **);
extern int pthread_attr_setdetachstate(pthread_attr_t *, int);
extern int pthread_attr_getdetachstate(const pthread_attr_t *, int *);
extern int pthread_attr_setscope(pthread_attr_t *, int);
extern int pthread_attr_getscope(const pthread_attr_t *, int *);
extern int pthread_attr_setinheritsched(pthread_attr_t *, int);
extern int pthread_attr_getinheritsched(const pthread_attr_t *, int *);
extern int pthread_attr_setschedpolicy(pthread_attr_t *, int);
extern int pthread_attr_getschedpolicy(const pthread_attr_t *, int *);
extern int pthread_attr_setschedparam(pthread_attr_t *,
                                        const struct sched_param *);
extern int pthread_attr_getschedparam(const pthread_attr_t *,
                                        struct sched_param *);
extern int pthread_create(pthread_t *, const pthread_attr_t *,
                                void * (*)(void *), void *);
extern int pthread_once(pthread_once_t *, void (*)(void));
extern int pthread_join(pthread_t, void **);
extern int pthread_detach(pthread_t);
extern void pthread_exit(void *);
extern int pthread_cancel(pthread_t);
extern int pthread_setschedparam(pthread_t, int, const struct sched_param *);
extern int pthread_getschedparam(pthread_t, int *, struct sched_param *);
extern int pthread_setcancelstate(int, int *);
extern int pthread_setcanceltype(int, int *);
extern void pthread_testcancel(void);
extern int pthread_equal(pthread_t, pthread_t);
extern int pthread_key_create(pthread_key_t *, void (*)(void *));
extern int pthread_key_delete(pthread_key_t);
extern int pthread_setspecific(pthread_key_t, const void *);
extern void *pthread_getspecific(pthread_key_t);
extern pthread_t pthread_self(void);




extern int pthread_mutexattr_init(pthread_mutexattr_t *);
extern int pthread_mutexattr_destroy(pthread_mutexattr_t *);
extern int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
extern int pthread_mutexattr_getpshared(const pthread_mutexattr_t *, int *);
extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *, int *);
extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *, int *);
extern int pthread_mutexattr_setrobust_np(pthread_mutexattr_t *, int);
extern int pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *, int *);
extern int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *);
extern int pthread_mutex_consistent_np(pthread_mutex_t *);
extern int pthread_mutex_destroy(pthread_mutex_t *);
extern int pthread_mutex_lock(pthread_mutex_t *);
extern int pthread_mutex_unlock(pthread_mutex_t *);
extern int pthread_mutex_trylock(pthread_mutex_t *);
extern int pthread_mutex_setprioceiling(pthread_mutex_t *, int, int *);
extern int pthread_mutex_getprioceiling(const pthread_mutex_t *, int *);
extern int pthread_condattr_init(pthread_condattr_t *);
extern int pthread_condattr_destroy(pthread_condattr_t *);
extern int pthread_condattr_setpshared(pthread_condattr_t *, int);
extern int pthread_condattr_getpshared(const pthread_condattr_t *, int *);
extern int pthread_cond_init(pthread_cond_t *, const pthread_condattr_t *);
extern int pthread_cond_destroy(pthread_cond_t *);
extern int pthread_cond_broadcast(pthread_cond_t *);
extern int pthread_cond_signal(pthread_cond_t *);
extern int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *);
extern int pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *,
                                        const struct timespec *);
extern int pthread_attr_getguardsize(const pthread_attr_t *, size_t *);
extern int pthread_attr_setguardsize(pthread_attr_t *, size_t);
extern int pthread_getconcurrency(void);
extern int pthread_setconcurrency(int newval);
extern int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *, int *);
extern int pthread_rwlock_init(pthread_rwlock_t *,
                                const pthread_rwlockattr_t *);
extern int pthread_rwlock_destroy(pthread_rwlock_t *);
extern int pthread_rwlock_rdlock(pthread_rwlock_t *);
extern int pthread_rwlock_tryrdlock(pthread_rwlock_t *);
extern int pthread_rwlock_wrlock(pthread_rwlock_t *);
extern int pthread_rwlock_trywrlock(pthread_rwlock_t *);
extern int pthread_rwlock_unlock(pthread_rwlock_t *);
extern int pthread_rwlockattr_init(pthread_rwlockattr_t *);
extern int pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
extern int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *, int *);
extern int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);
# 340 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/pthread.h" 3 4
}
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr-default.h" 2 3

typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;






#pragma weak pthread_once
#pragma weak pthread_key_create
#pragma weak pthread_key_delete
#pragma weak pthread_getspecific
#pragma weak pthread_setspecific
#pragma weak pthread_create

#pragma weak pthread_mutex_lock
#pragma weak pthread_mutex_trylock
#pragma weak pthread_mutex_unlock
# 80 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr-default.h" 3
static void *__gthread_active_ptr = (void *) &pthread_create;

static inline int
__gthread_active_p (void)
{
  return __gthread_active_ptr != 0;
}
# 438 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr-default.h" 3
static inline int
__gthread_once (__gthread_once_t *once, void (*func) (void))
{
  if (__gthread_active_p ())
    return pthread_once (once, func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
  return pthread_key_create (key, dtor);
}

static inline int
__gthread_key_dtor (__gthread_key_t key, void *ptr)
{

  if (ptr)
    return pthread_setspecific (key, 0);
  else
    return 0;
}

static inline int
__gthread_key_delete (__gthread_key_t key)
{
  return pthread_key_delete (key);
}

static inline void *
__gthread_getspecific (__gthread_key_t key)
{
  return pthread_getspecific (key);
}

static inline int
__gthread_setspecific (__gthread_key_t key, const void *ptr)
{
  return pthread_setspecific (key, ptr);
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_lock (mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_trylock (mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_unlock (mutex);
  else
    return 0;
}
# 99 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr.h" 2 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++io.h" 2 3

namespace std
{

  typedef long streamoff;
  typedef ptrdiff_t streamsize;



  typedef fpos_t __c_streampos;

  typedef __gthread_mutex_t __c_lock;



  typedef FILE __c_file_type;


  struct __ios_flags
  {
    typedef short __int_type;

    static const __int_type _S_boolalpha = 0x0001;
    static const __int_type _S_dec = 0x0002;
    static const __int_type _S_fixed = 0x0004;
    static const __int_type _S_hex = 0x0008;
    static const __int_type _S_internal = 0x0010;
    static const __int_type _S_left = 0x0020;
    static const __int_type _S_oct = 0x0040;
    static const __int_type _S_right = 0x0080;
    static const __int_type _S_scientific = 0x0100;
    static const __int_type _S_showbase = 0x0200;
    static const __int_type _S_showpoint = 0x0400;
    static const __int_type _S_showpos = 0x0800;
    static const __int_type _S_skipws = 0x1000;
    static const __int_type _S_unitbuf = 0x2000;
    static const __int_type _S_uppercase = 0x4000;
    static const __int_type _S_adjustfield = 0x0020 | 0x0080 | 0x0010;
    static const __int_type _S_basefield = 0x0002 | 0x0040 | 0x0008;
    static const __int_type _S_floatfield = 0x0100 | 0x0004;


    static const __int_type _S_badbit = 0x01;
    static const __int_type _S_eofbit = 0x02;
    static const __int_type _S_failbit = 0x04;


    static const __int_type _S_app = 0x01;
    static const __int_type _S_ate = 0x02;
    static const __int_type _S_bin = 0x04;
    static const __int_type _S_in = 0x08;
    static const __int_type _S_out = 0x10;
    static const __int_type _S_trunc = 0x20;
  };
}
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/fpos.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cwchar.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cwchar.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cwchar.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cwchar.h" 2 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cwchar.h" 3
# 1 "/usr/include/wchar.h" 1 3 4
# 9 "/usr/include/wchar.h" 3 4
#pragma ident "@(#)wchar.h	1.33	99/08/30 SMI"

# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 1 3 4
# 30 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
#pragma ident "@(#)wchar_iso.h	1.2	99/11/10 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 33 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4
# 1 "/usr/include/stdio_tag.h" 1 3 4
# 34 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4
# 1 "/usr/include/wchar_impl.h" 1 3 4
# 9 "/usr/include/wchar_impl.h" 3 4
#pragma ident "@(#)wchar_impl.h	1.3	99/07/26 SMI"

# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 12 "/usr/include/wchar_impl.h" 2 3 4


extern "C" {




typedef struct __mbstate_t {

        long __filler[4];



} __mbstate_t;



}
# 35 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4
# 1 "/usr/include/iso/time_iso.h" 1 3 4
# 36 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4




# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stdio.h" 1 3 4
# 41 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4



# 1 "/usr/include/ctype.h" 1 3 4
# 16 "/usr/include/ctype.h" 3 4
#pragma ident "@(#)ctype.h	1.33	99/08/10 SMI"

# 1 "/usr/include/iso/ctype_iso.h" 1 3 4
# 28 "/usr/include/iso/ctype_iso.h" 3 4
#pragma ident "@(#)ctype_iso.h	1.1	99/08/09 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 31 "/usr/include/iso/ctype_iso.h" 2 3 4


extern "C" {
# 63 "/usr/include/iso/ctype_iso.h" 3 4
extern int isalnum(int);
extern int isalpha(int);
extern int iscntrl(int);
extern int isdigit(int);
extern int isgraph(int);
extern int islower(int);
extern int isprint(int);
extern int ispunct(int);
extern int isspace(int);
extern int isupper(int);
extern int isxdigit(int);







extern int tolower(int);
extern int toupper(int);





extern unsigned char __ctype[];
extern unsigned int *__ctype_mask;
extern int *__trans_upper;
extern int *__trans_lower;
# 186 "/usr/include/iso/ctype_iso.h" 3 4
}
# 19 "/usr/include/ctype.h" 2 3 4
# 41 "/usr/include/ctype.h" 3 4
extern "C" {







extern int isascii(int);
extern int toascii(int);
extern int _tolower(int);
extern int _toupper(int);
# 90 "/usr/include/ctype.h" 3 4
}
# 45 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4
# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/stddef.h" 1 3 4
# 46 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4


# 1 "/usr/include/sys/va_list.h" 1 3 4
# 49 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 2 3 4


extern "C" {
# 74 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
typedef int wint_t;
# 113 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
typedef __mbstate_t mbstate_t;
# 124 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
extern wint_t fgetwc(__FILE *);
extern wchar_t *fgetws(wchar_t *, int, __FILE *);
extern wint_t fputwc(wint_t, __FILE *);
extern int fputws(const wchar_t *, __FILE *);
extern wint_t ungetwc(wint_t, __FILE *);
extern wint_t getwc(__FILE *);
extern wint_t getwchar(void);
extern wint_t putwc(wint_t, __FILE *);
extern wint_t putwchar(wint_t);
extern double wcstod(const wchar_t *, wchar_t **);
extern long wcstol(const wchar_t *, wchar_t **, int);
extern unsigned long wcstoul(const wchar_t *, wchar_t **, int);
extern wchar_t *wcscat(wchar_t *, const wchar_t *);
extern int wcscmp(const wchar_t *, const wchar_t *);
extern int wcscoll(const wchar_t *, const wchar_t *);
extern wchar_t *wcscpy(wchar_t *, const wchar_t *);
extern size_t wcscspn(const wchar_t *, const wchar_t *);
extern size_t wcslen(const wchar_t *);
extern wchar_t *wcsncat(wchar_t *, const wchar_t *, size_t);
extern int wcsncmp(const wchar_t *, const wchar_t *, size_t);
extern wchar_t *wcsncpy(wchar_t *, const wchar_t *, size_t);
extern size_t wcsspn(const wchar_t *, const wchar_t *);
extern size_t wcsxfrm(wchar_t *, const wchar_t *, size_t);
# 167 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
extern wchar_t *wcschr(const wchar_t *, wchar_t);
extern wchar_t *wcspbrk(const wchar_t *, const wchar_t *);
extern wchar_t *wcsrchr(const wchar_t *, wchar_t);
# 183 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
extern wchar_t *__wcstok_xpg5(wchar_t *, const wchar_t *, wchar_t **);
extern size_t __wcsftime_xpg5(wchar_t *, size_t, const wchar_t *,
        const struct tm *);
# 194 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
extern wint_t btowc(int);
extern int fwprintf(__FILE *, const wchar_t *, ...);
extern int fwscanf(__FILE *, const wchar_t *, ...);
extern int fwide(__FILE *, int);
extern int mbsinit(const mbstate_t *);
extern size_t mbrlen(const char *, size_t, mbstate_t *);
extern size_t mbrtowc(wchar_t *, const char *, size_t, mbstate_t *);
extern size_t mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *);
extern int swprintf(wchar_t *, size_t, const wchar_t *, ...);
extern int swscanf(const wchar_t *, const wchar_t *, ...);
extern int vfwprintf(__FILE *, const wchar_t *, __va_list);
extern int vwprintf(const wchar_t *, __va_list);
extern int vswprintf(wchar_t *, size_t, const wchar_t *, __va_list);
extern size_t wcrtomb(char *, wchar_t, mbstate_t *);
extern size_t wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);
extern int wctob(wint_t);
extern int wmemcmp(const wchar_t *, const wchar_t *, size_t);
extern wchar_t *wmemcpy(wchar_t *, const wchar_t *, size_t);
extern wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t);
extern wchar_t *wmemset(wchar_t *, wchar_t, size_t);
extern int wprintf(const wchar_t *, ...);
extern int wscanf(const wchar_t *, ...);
# 230 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
extern wchar_t *wcsstr(const wchar_t *, const wchar_t *);
extern wchar_t *wmemchr(const wchar_t *, wchar_t, size_t);
# 329 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
extern wint_t __fgetwc_xpg5(__FILE *);
extern wint_t __getwc_xpg5(__FILE *);
extern wint_t __getwchar_xpg5(void);
extern wint_t __fputwc_xpg5(wint_t, __FILE *);
extern wint_t __putwc_xpg5(wint_t, __FILE *);
extern wint_t __putwchar_xpg5(wint_t);
extern wchar_t *__fgetws_xpg5(wchar_t *, int, __FILE *);
extern int __fputws_xpg5(const wchar_t *, __FILE *);
extern wint_t __ungetwc_xpg5(wint_t, __FILE *);
# 367 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/iso/wchar_iso.h" 3 4
}
# 12 "/usr/include/wchar.h" 2 3 4
# 81 "/usr/include/wchar.h" 3 4
extern "C" {





typedef int wctype_t;






extern int iswalpha(wint_t);
extern int iswupper(wint_t);
extern int iswlower(wint_t);
extern int iswdigit(wint_t);
extern int iswxdigit(wint_t);
extern int iswalnum(wint_t);
extern int iswspace(wint_t);
extern int iswpunct(wint_t);
extern int iswprint(wint_t);
extern int iswgraph(wint_t);
extern int iswcntrl(wint_t);
extern int iswctype(wint_t, wctype_t);
extern wint_t towlower(wint_t);
extern wint_t towupper(wint_t);
extern wchar_t *wcswcs(const wchar_t *, const wchar_t *);
extern int wcswidth(const wchar_t *, size_t);
extern int wcwidth(const wchar_t);
extern wctype_t wctype(const char *);
# 140 "/usr/include/wchar.h" 3 4
}
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cwchar.h" 2 3
# 57 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cwchar.h" 3
namespace std
{
  using ::mbstate_t;
}
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/fpos.h" 2 3

namespace std
{



  template<typename _StateT>
    class fpos
    {
    public:

      typedef _StateT __state_type;

    private:
      streamoff _M_off;
      __state_type _M_st;

    public:
      __state_type
      state() const { return _M_st; }

      void
      state(__state_type __st) { _M_st = __st; }



      fpos(): _M_off(streamoff()), _M_st(__state_type()) { }

      fpos(streamoff __off, __state_type __st = __state_type())
      : _M_off(__off), _M_st(__st) { }

      operator streamoff() const { return _M_off; }

      fpos&
      operator+=(streamoff __off) { _M_off += __off; return *this; }

      fpos&
      operator-=(streamoff __off) { _M_off -= __off; return *this; }

      fpos
      operator+(streamoff __off)
      {
        fpos __t(*this);
        __t += __off;
        return __t;
      }

      fpos
      operator-(streamoff __off)
      {
        fpos __t(*this);
        __t -= __off;
        return __t;
      }

      bool
      operator==(const fpos& __pos) const
      { return _M_off == __pos._M_off; }

      bool
      operator!=(const fpos& __pos) const
      { return _M_off != __pos._M_off; }

      streamoff
      _M_position() const { return _M_off; }

      void
      _M_position(streamoff __off) { _M_off = __off; }
    };


  typedef fpos<mbstate_t> streampos;



}
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception_defines.h" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 2 3

namespace std
{
  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ios;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_streambuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_istream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_iostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
            typename _Alloc = allocator<_CharT> >
    class basic_stringbuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_istringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_ostringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_stringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_filebuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ifstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ofstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_fstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class ostreambuf_iterator;



  class ios_base;


  typedef basic_ios<char> ios;
  typedef basic_streambuf<char> streambuf;
  typedef basic_istream<char> istream;
  typedef basic_ostream<char> ostream;
  typedef basic_iostream<char> iostream;
  typedef basic_stringbuf<char> stringbuf;
  typedef basic_istringstream<char> istringstream;
  typedef basic_ostringstream<char> ostringstream;
  typedef basic_stringstream<char> stringstream;
  typedef basic_filebuf<char> filebuf;
  typedef basic_ifstream<char> ifstream;
  typedef basic_ofstream<char> ofstream;
  typedef basic_fstream<char> fstream;
# 129 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 3
}
# 78 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_types.h" 1 3
# 69 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_types.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 71 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_types.h" 2 3


namespace std
{

struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};






template <class _Tp, class _Distance> struct input_iterator {
  typedef input_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};

struct output_iterator {
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;
};

template <class _Tp, class _Distance> struct forward_iterator {
  typedef forward_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};


template <class _Tp, class _Distance> struct bidirectional_iterator {
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};

template <class _Tp, class _Distance> struct random_access_iterator {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};

template <class _Category, class _Tp, class _Distance = ptrdiff_t,
          class _Pointer = _Tp*, class _Reference = _Tp&>
struct iterator {
  typedef _Category iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Pointer pointer;
  typedef _Reference reference;
};

template <class _Iterator>
struct iterator_traits {
  typedef typename _Iterator::iterator_category iterator_category;
  typedef typename _Iterator::value_type value_type;
  typedef typename _Iterator::difference_type difference_type;
  typedef typename _Iterator::pointer pointer;
  typedef typename _Iterator::reference reference;
};

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

template <class _Tp>
struct iterator_traits<const _Tp*> {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef ptrdiff_t difference_type;
  typedef const _Tp* pointer;
  typedef const _Tp& reference;
};
# 172 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_types.h" 3
template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{
  typedef typename iterator_traits<_Iter>::iterator_category _Category;
  return _Category();
}

template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type*
__distance_type(const _Iter&)
{
  return static_cast<typename iterator_traits<_Iter>::difference_type*>(0);
}

template <class _Iter>
inline typename iterator_traits<_Iter>::value_type*
__value_type(const _Iter&)
{
  return static_cast<typename iterator_traits<_Iter>::value_type*>(0);
}

template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
iterator_category(const _Iter& __i) { return __iterator_category(__i); }


template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type*
distance_type(const _Iter& __i) { return __distance_type(__i); }

template <class _Iter>
inline typename iterator_traits<_Iter>::value_type*
value_type(const _Iter& __i) { return __value_type(__i); }

}
# 79 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_funcs.h" 1 3
# 69 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_funcs.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/concept_check.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/concept_check.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 36 "/usr/local/gcc-3.0.1/include/g++-v3/bits/concept_check.h" 2 3
# 70 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_funcs.h" 2 3

namespace std
{





template <class _InputIterator, class _Distance>
inline void __distance(_InputIterator __first, _InputIterator __last,
                       _Distance& __n, input_iterator_tag)
{

                                                                    ;
  while (__first != __last) { ++__first; ++__n; }
}

template <class _RandomAccessIterator, class _Distance>
inline void __distance(_RandomAccessIterator __first,
                       _RandomAccessIterator __last,
                       _Distance& __n, random_access_iterator_tag)
{

                                                                                  ;
  __n += __last - __first;
}

template <class _InputIterator, class _Distance>
inline void distance(_InputIterator __first,
                     _InputIterator __last, _Distance& __n)
{

  __distance(__first, __last, __n, iterator_category(__first));
}

template <class _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
{

                                                                    ;
  typename iterator_traits<_InputIterator>::difference_type __n = 0;
  while (__first != __last) {
    ++__first; ++__n;
  }
  return __n;
}

template <class _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
           random_access_iterator_tag)
{

                                                                                  ;
  return __last - __first;
}

template <class _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
{

  typedef typename iterator_traits<_InputIterator>::iterator_category
    _Category;
  return __distance(__first, __last, _Category());
}

template <class _InputIter, class _Distance>
inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag)
{

                                                                ;
  while (__n--) ++__i;
}

template <class _BidirectionalIterator, class _Distance>
inline void __advance(_BidirectionalIterator& __i, _Distance __n,
                      bidirectional_iterator_tag)
{

                                                                                  ;
  if (__n > 0)
    while (__n--) ++__i;
  else
    while (__n++) --__i;
}

template <class _RandomAccessIterator, class _Distance>
inline void __advance(_RandomAccessIterator& __i, _Distance __n,
                      random_access_iterator_tag)
{

                                                                                  ;
  __i += __n;
}

template <class _InputIterator, class _Distance>
inline void advance(_InputIterator& __i, _Distance __n)
{

  __advance(__i, __n, iterator_category(__i));
}

}
# 80 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator.h" 3
namespace std
{

template <class _Container>
class back_insert_iterator {
protected:
  _Container* container;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  explicit back_insert_iterator(_Container& __x) : container(&__x) {}
  back_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    container->push_back(__value);
    return *this;
  }
  back_insert_iterator<_Container>& operator*() { return *this; }
  back_insert_iterator<_Container>& operator++() { return *this; }
  back_insert_iterator<_Container>& operator++(int) { return *this; }
};

template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) {
  return back_insert_iterator<_Container>(__x);
}

template <class _Container>
class front_insert_iterator {
protected:
  _Container* container;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  explicit front_insert_iterator(_Container& __x) : container(&__x) {}
  front_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    container->push_front(__value);
    return *this;
  }
  front_insert_iterator<_Container>& operator*() { return *this; }
  front_insert_iterator<_Container>& operator++() { return *this; }
  front_insert_iterator<_Container>& operator++(int) { return *this; }
};

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) {
  return front_insert_iterator<_Container>(__x);
}

template <class _Container>
class insert_iterator {
protected:
  _Container* container;
  typename _Container::iterator iter;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) {}
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  }
  insert_iterator<_Container>& operator*() { return *this; }
  insert_iterator<_Container>& operator++() { return *this; }
  insert_iterator<_Container>& operator++(int) { return *this; }
};

template <class _Container, class _Iterator>
inline
insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
{
  typedef typename _Container::iterator __iter;
  return insert_iterator<_Container>(__x, __iter(__i));
}

template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t>
class reverse_bidirectional_iterator {
  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                         _Reference, _Distance> _Self;
protected:
  _BidirectionalIterator current;
public:
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Reference reference;

  reverse_bidirectional_iterator() {}
  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
    : current(__x) {}
  _BidirectionalIterator base() const { return current; }
  _Reference operator*() const {
    _BidirectionalIterator __tmp = current;
    return *--__tmp;
  }
  pointer operator->() const { return &(operator*()); }
  _Self& operator++() {
    --current;
    return *this;
  }
  _Self operator++(int) {
    _Self __tmp = *this;
    --current;
    return __tmp;
  }
  _Self& operator--() {
    ++current;
    return *this;
  }
  _Self operator--(int) {
    _Self __tmp = *this;
    ++current;
    return __tmp;
  }
};

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator==(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x,
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
{
  return __x.base() == __y.base();
}

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator!=(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x,
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
{
  return !(__x == __y);
}
# 222 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator.h" 3
template <class _Iterator>
class reverse_iterator
{
protected:
  _Iterator current;
public:
  typedef typename iterator_traits<_Iterator>::iterator_category
          iterator_category;
  typedef typename iterator_traits<_Iterator>::value_type
          value_type;
  typedef typename iterator_traits<_Iterator>::difference_type
          difference_type;
  typedef typename iterator_traits<_Iterator>::pointer
          pointer;
  typedef typename iterator_traits<_Iterator>::reference
          reference;

  typedef _Iterator iterator_type;
  typedef reverse_iterator<_Iterator> _Self;

public:
  reverse_iterator() {}
  explicit reverse_iterator(iterator_type __x) : current(__x) {}

  reverse_iterator(const _Self& __x) : current(__x.current) {}
  template <class _Iter>
  reverse_iterator(const reverse_iterator<_Iter>& __x)
    : current(__x.base()) {}

  iterator_type base() const { return current; }
  reference operator*() const {
    _Iterator __tmp = current;
    return *--__tmp;
  }
  pointer operator->() const { return &(operator*()); }

  _Self& operator++() {
    --current;
    return *this;
  }
  _Self operator++(int) {
    _Self __tmp = *this;
    --current;
    return __tmp;
  }
  _Self& operator--() {
    ++current;
    return *this;
  }
  _Self operator--(int) {
    _Self __tmp = *this;
    ++current;
    return __tmp;
  }

  _Self operator+(difference_type __n) const {
    return _Self(current - __n);
  }
  _Self& operator+=(difference_type __n) {
    current -= __n;
    return *this;
  }
  _Self operator-(difference_type __n) const {
    return _Self(current + __n);
  }
  _Self& operator-=(difference_type __n) {
    current += __n;
    return *this;
  }
  reference operator[](difference_type __n) const { return *(*this + __n); }
};

template <class _Iterator>
inline bool operator==(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) {
  return __x.base() == __y.base();
}

template <class _Iterator>
inline bool operator<(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) {
  return __y.base() < __x.base();
}

template <class _Iterator>
inline bool operator!=(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) {
  return !(__x == __y);
}

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) {
  return __y < __x;
}

template <class _Iterator>
inline bool operator<=(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) {
  return !(__y < __x);
}

template <class _Iterator>
inline bool operator>=(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) {
  return !(__x < __y);
}

template <class _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
          const reverse_iterator<_Iterator>& __y) {
  return __y.base() - __x.base();
}

template <class _Iterator>
inline reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
          const reverse_iterator<_Iterator>& __x) {
  return reverse_iterator<_Iterator>(__x.base() - __n);
}


template <class _Tp,
          class _CharT = char, class _Traits = char_traits<_CharT>,
          class _Dist = ptrdiff_t>
class istream_iterator {
public:
  typedef _CharT char_type;
  typedef _Traits traits_type;
  typedef basic_istream<_CharT, _Traits> istream_type;

  typedef input_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Dist difference_type;
  typedef const _Tp* pointer;
  typedef const _Tp& reference;

  istream_iterator() : _M_stream(0), _M_ok(false) {}
  istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); }

  reference operator*() const { return _M_value; }
  pointer operator->() const { return &(operator*()); }

  istream_iterator& operator++() {
    _M_read();
    return *this;
  }
  istream_iterator operator++(int) {
    istream_iterator __tmp = *this;
    _M_read();
    return __tmp;
  }

  bool _M_equal(const istream_iterator& __x) const
    { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }

private:
  istream_type* _M_stream;
  _Tp _M_value;
  bool _M_ok;

  void _M_read() {
    _M_ok = (_M_stream && *_M_stream) ? true : false;
    if (_M_ok) {
      *_M_stream >> _M_value;
      _M_ok = *_M_stream ? true : false;
    }
  }
};

template <class _Tp, class _CharT, class _Traits, class _Dist>
inline bool
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
           const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) {
  return __x._M_equal(__y);
}

template <class _Tp, class _CharT, class _Traits, class _Dist>
inline bool
operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
           const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) {
  return !__x._M_equal(__y);
}


template <class _Tp,
          class _CharT = char, class _Traits = char_traits<_CharT> >
class ostream_iterator {
public:
  typedef _CharT char_type;
  typedef _Traits traits_type;
  typedef basic_ostream<_CharT, _Traits> ostream_type;

  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
  ostream_iterator(ostream_type& __s, const _CharT* __c)
    : _M_stream(&__s), _M_string(__c) {}
  ostream_iterator<_Tp>& operator=(const _Tp& __value) {
    *_M_stream << __value;
    if (_M_string) *_M_stream << _M_string;
    return *this;
  }
  ostream_iterator<_Tp>& operator*() { return *this; }
  ostream_iterator<_Tp>& operator++() { return *this; }
  ostream_iterator<_Tp>& operator++(int) { return *this; }
private:
  ostream_type* _M_stream;
  const _CharT* _M_string;
};
# 446 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator.h" 3
template<typename _Iterator, typename _Container>
class __normal_iterator
  : public iterator<iterator_traits<_Iterator>::iterator_category,
                    iterator_traits<_Iterator>::value_type,
                    iterator_traits<_Iterator>::difference_type,
                    iterator_traits<_Iterator>::pointer,
                    iterator_traits<_Iterator>::reference>
{

protected:
  _Iterator _M_current;

public:
  typedef __normal_iterator<_Iterator, _Container> normal_iterator_type;
  typedef iterator_traits<_Iterator> __traits_type;
  typedef typename __traits_type::iterator_category iterator_category;
  typedef typename __traits_type::value_type value_type;
  typedef typename __traits_type::difference_type difference_type;
  typedef typename __traits_type::pointer pointer;
  typedef typename __traits_type::reference reference;

  __normal_iterator() : _M_current(_Iterator()) { }

  explicit __normal_iterator(const _Iterator& __i) : _M_current(__i) { }


  template<typename _Iter>
  inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
    : _M_current(__i.base()) { }


  reference
  operator*() const { return *_M_current; }

  pointer
  operator->() const { return _M_current; }

  normal_iterator_type&
  operator++() { ++_M_current; return *this; }

  normal_iterator_type
  operator++(int) { return __normal_iterator(_M_current++); }


  normal_iterator_type&
  operator--() { --_M_current; return *this; }

  normal_iterator_type
  operator--(int) { return __normal_iterator(_M_current--); }


  reference
  operator[](const difference_type& __n) const
  { return _M_current[__n]; }

  normal_iterator_type&
  operator+=(const difference_type& __n)
  { _M_current += __n; return *this; }

  normal_iterator_type
  operator+(const difference_type& __n) const
  { return __normal_iterator(_M_current + __n); }

  normal_iterator_type&
  operator-=(const difference_type& __n)
  { _M_current -= __n; return *this; }

  normal_iterator_type
  operator-(const difference_type& __n) const
  { return __normal_iterator(_M_current - __n); }

  difference_type
  operator-(const normal_iterator_type& __i) const
  { return _M_current - __i._M_current; }

  const _Iterator&
  base() const { return _M_current; }
};



template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return !(__lhs == __rhs); }



template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
          const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
          const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __rhs < __lhs; }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return !(__rhs < __lhs); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return !(__lhs < __rhs); }

template<typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container>
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
          const __normal_iterator<_Iterator, _Container>& __i)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

}
# 81 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/concept_check.h" 1 3
# 82 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 2 3

namespace std
{



template <class _ForwardIter1, class _ForwardIter2, class _Tp>
inline void __iter_swap(_ForwardIter1 __a, _ForwardIter2 __b, _Tp*)
{
  _Tp __tmp = *__a;
  *__a = *__b;
  *__b = __tmp;
}

template <class _ForwardIter1, class _ForwardIter2>
inline void iter_swap(_ForwardIter1 __a, _ForwardIter2 __b)
{

                                                                             ;
                                                                             ;
                                                             ;


                                                             ;



  __iter_swap(__a, __b, __value_type(__a));
}

template <class _Tp>
inline void swap(_Tp& __a, _Tp& __b)
{

                                                         ;

  _Tp __tmp = __a;
  __a = __b;
  __b = __tmp;
}







template <class _Tp>
inline const _Tp& min(const _Tp& __a, const _Tp& __b) {

                                                              ;

  if (__b < __a) return __b; return __a;
}

template <class _Tp>
inline const _Tp& max(const _Tp& __a, const _Tp& __b) {

                                                              ;

  if (__a < __b) return __b; return __a;
}

template <class _Tp, class _Compare>
inline const _Tp& min(const _Tp& __a, const _Tp& __b, _Compare __comp) {

  if (__comp(__b, __a)) return __b; return __a;
}

template <class _Tp, class _Compare>
inline const _Tp& max(const _Tp& __a, const _Tp& __b, _Compare __comp) {

  if (__comp(__a, __b)) return __b; return __a;
}
# 166 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 3
template <class _InputIter, class _OutputIter, class _Distance>
inline _OutputIter __copy(_InputIter __first, _InputIter __last,
                          _OutputIter __result,
                          input_iterator_tag, _Distance*)
{
  for ( ; __first != __last; ++__result, ++__first)
    *__result = *__first;
  return __result;
}

template <class _RandomAccessIter, class _OutputIter, class _Distance>
inline _OutputIter
__copy(_RandomAccessIter __first, _RandomAccessIter __last,
       _OutputIter __result, random_access_iterator_tag, _Distance*)
{
  for (_Distance __n = __last - __first; __n > 0; --__n) {
    *__result = *__first;
    ++__first;
    ++__result;
  }
  return __result;
}

template <class _Tp>
inline _Tp*
__copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result)
{
  memmove(__result, __first, sizeof(_Tp) * (__last - __first));
  return __result + (__last - __first);
}


template <class _InputIter, class _OutputIter>
inline _OutputIter __copy_aux2(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __false_type)
{
  return __copy(__first, __last, __result,
                __iterator_category(__first),
                __distance_type(__first));
}

template <class _InputIter, class _OutputIter>
inline _OutputIter __copy_aux2(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __true_type)
{
  return __copy(__first, __last, __result,
                __iterator_category(__first),
                __distance_type(__first));
}

template <class _Tp>
inline _Tp* __copy_aux2(_Tp* __first, _Tp* __last, _Tp* __result,
                        __true_type)
{
  return __copy_trivial(__first, __last, __result);
}

template <class _Tp>
inline _Tp* __copy_aux2(const _Tp* __first, const _Tp* __last, _Tp* __result,
                        __true_type)
{
  return __copy_trivial(__first, __last, __result);
}


template <class _InputIter, class _OutputIter, class _Tp>
inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last,
                              _OutputIter __result, _Tp*)
{
  typedef typename __type_traits<_Tp>::has_trivial_assignment_operator
          _Trivial;
  return __copy_aux2(__first, __last, __result, _Trivial());
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni2(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __true_type)
{
  return _OutputIter(__copy_aux(__first, __last, __result.base(),
                                __value_type(__first)));
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni2(_InputIter __first, _InputIter __last,
                              _OutputIter __result, __false_type)
{
  return __copy_aux(__first, __last, __result, __value_type(__first));
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni1(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __true_type)
{
  typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
  return __copy_ni2(__first.base(), __last.base(), __result, __Normal());
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni1(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __false_type)
{
  typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
  return __copy_ni2(__first, __last, __result, __Normal());
}

template <class _InputIter, class _OutputIter>
inline _OutputIter copy(_InputIter __first, _InputIter __last,
                        _OutputIter __result)
{

                                                                ;
                                                          ;


   typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal;
   return __copy_ni1(__first, __last, __result, __Normal());
}




template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _Distance>
inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first,
                                           _BidirectionalIter1 __last,
                                           _BidirectionalIter2 __result,
                                           bidirectional_iterator_tag,
                                           _Distance*)
{
  while (__first != __last)
    *--__result = *--__last;
  return __result;
}

template <class _RandomAccessIter, class _BidirectionalIter, class _Distance>
inline _BidirectionalIter __copy_backward(_RandomAccessIter __first,
                                          _RandomAccessIter __last,
                                          _BidirectionalIter __result,
                                          random_access_iterator_tag,
                                          _Distance*)
{
  for (_Distance __n = __last - __first; __n > 0; --__n)
    *--__result = *--__last;
  return __result;
}







template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BoolType>
struct __copy_backward_dispatch
{
  typedef typename iterator_traits<_BidirectionalIter1>::iterator_category
          _Cat;
  typedef typename iterator_traits<_BidirectionalIter1>::difference_type
          _Distance;

  static _BidirectionalIter2 copy(_BidirectionalIter1 __first,
                                  _BidirectionalIter1 __last,
                                  _BidirectionalIter2 __result) {
    return __copy_backward(__first, __last, __result, _Cat(), (_Distance*) 0);
  }
};

template <class _Tp>
struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
{
  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
    const ptrdiff_t _Num = __last - __first;
    memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
    return __result - _Num;
  }
};

template <class _Tp>
struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type>
{
  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
    return __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
      ::copy(__first, __last, __result);
  }
};

template <class _BI1, class _BI2>
inline _BI2 __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result) {
  typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
                        ::has_trivial_assignment_operator
          _Trivial;
  return __copy_backward_dispatch<_BI1, _BI2, _Trivial>
              ::copy(__first, __last, __result);
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
                                                   _BI2 __result, __true_type) {
  return _BI2(__copy_backward_aux(__first, __last, __result.base()));
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
                                                   _BI2 __result, __false_type){
  return __copy_backward_aux(__first, __last, __result);
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
                                                  _BI2 __result, __true_type) {
  typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
  return __copy_backward_output_normal_iterator(__first.base(), __last.base(),
                                                __result, __Normal());
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
                                                  _BI2 __result, __false_type) {
  typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
  return __copy_backward_output_normal_iterator(__first, __last, __result,
                                                __Normal());
}

template <typename _BI1, typename _BI2>
inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{

                                                                  ;
                                                                          ;
                                                    ;



  typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
  return __copy_backward_input_normal_iterator(__first, __last, __result,
                                               __Normal());
}




template <class _InputIter, class _Size, class _OutputIter>
pair<_InputIter, _OutputIter> __copy_n(_InputIter __first, _Size __count,
                                       _OutputIter __result,
                                       input_iterator_tag) {
  for ( ; __count > 0; --__count) {
    *__result = *__first;
    ++__first;
    ++__result;
  }
  return pair<_InputIter, _OutputIter>(__first, __result);
}

template <class _RAIter, class _Size, class _OutputIter>
inline pair<_RAIter, _OutputIter>
__copy_n(_RAIter __first, _Size __count,
         _OutputIter __result,
         random_access_iterator_tag) {
  _RAIter __last = __first + __count;
  return pair<_RAIter, _OutputIter>(__last, copy(__first, __last, __result));
}

template <class _InputIter, class _Size, class _OutputIter>
inline pair<_InputIter, _OutputIter>
__copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
  return __copy_n(__first, __count, __result,
                  __iterator_category(__first));
}

template <class _InputIter, class _Size, class _OutputIter>
inline pair<_InputIter, _OutputIter>
copy_n(_InputIter __first, _Size __count, _OutputIter __result)
{

                                                                ;
                                                          ;


  return __copy_n(__first, __count, __result);
}





template <class _ForwardIter, class _Tp>
void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value)
{

                                                                            ;

  for ( ; __first != __last; ++__first)
    *__first = __value;
}

template <class _OutputIter, class _Size, class _Tp>
_OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __value)
{

                                                                      ;

  for ( ; __n > 0; --__n, ++__first)
    *__first = __value;
  return __first;
}



inline void fill(unsigned char* __first, unsigned char* __last,
                 const unsigned char& __c)
{
  unsigned char __tmp = __c;
  memset(__first, __tmp, __last - __first);
}

inline void fill(signed char* __first, signed char* __last,
                 const signed char& __c)
{
  signed char __tmp = __c;
  memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
}

inline void fill(char* __first, char* __last, const char& __c)
{
  char __tmp = __c;
  memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
}

template <class _Size>
inline unsigned char* fill_n(unsigned char* __first, _Size __n,
                             const unsigned char& __c)
{
  fill(__first, __first + __n, __c);
  return __first + __n;
}

template <class _Size>
inline signed char* fill_n(char* __first, _Size __n,
                           const signed char& __c)
{
  fill(__first, __first + __n, __c);
  return __first + __n;
}

template <class _Size>
inline char* fill_n(char* __first, _Size __n, const char& __c)
{
  fill(__first, __first + __n, __c);
  return __first + __n;
}





template <class _InputIter1, class _InputIter2>
pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
                                        _InputIter1 __last1,
                                        _InputIter2 __first2)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


  while (__first1 != __last1 && *__first1 == *__first2) {
    ++__first1;
    ++__first2;
  }
  return pair<_InputIter1, _InputIter2>(__first1, __first2);
}

template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
                                        _InputIter1 __last1,
                                        _InputIter2 __first2,
                                        _BinaryPredicate __binary_pred)
{

                                                                 ;
                                                                 ;

  while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
    ++__first1;
    ++__first2;
  }
  return pair<_InputIter1, _InputIter2>(__first1, __first2);
}

template <class _InputIter1, class _InputIter2>
inline bool equal(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2)
{

                                                                 ;
                                                                 ;
                                                           ;



  for ( ; __first1 != __last1; ++__first1, ++__first2)
    if (!(*__first1 == *__first2))
      return false;
  return true;
}

template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
inline bool equal(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2, _BinaryPredicate __binary_pred)
{

                                                                 ;
                                                                 ;

  for ( ; __first1 != __last1; ++__first1, ++__first2)
    if (!__binary_pred(*__first1, *__first2))
      return false;
  return true;
}





template <class _InputIter1, class _InputIter2>
bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


  for ( ; __first1 != __last1 && __first2 != __last2
        ; ++__first1, ++__first2) {
    if (*__first1 < *__first2)
      return true;
    if (*__first2 < *__first1)
      return false;
  }
  return __first1 == __last1 && __first2 != __last2;
}

template <class _InputIter1, class _InputIter2, class _Compare>
bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _Compare __comp)
{

                                                                 ;
                                                                 ;

  for ( ; __first1 != __last1 && __first2 != __last2
        ; ++__first1, ++__first2) {
    if (__comp(*__first1, *__first2))
      return true;
    if (__comp(*__first2, *__first1))
      return false;
  }
  return __first1 == __last1 && __first2 != __last2;
}

inline bool
lexicographical_compare(const unsigned char* __first1,
                        const unsigned char* __last1,
                        const unsigned char* __first2,
                        const unsigned char* __last2)
{
  const size_t __len1 = __last1 - __first1;
  const size_t __len2 = __last2 - __first2;
  const int __result = memcmp(__first1, __first2, min(__len1, __len2));
  return __result != 0 ? __result < 0 : __len1 < __len2;
}

inline bool lexicographical_compare(const char* __first1, const char* __last1,
                                    const char* __first2, const char* __last2)
{

  return lexicographical_compare((const signed char*) __first1,
                                 (const signed char*) __last1,
                                 (const signed char*) __first2,
                                 (const signed char*) __last2);






}

template <class _InputIter1, class _InputIter2>
int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
                                   _InputIter2 __first2, _InputIter2 __last2)
{
  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first1 < *__first2)
      return -1;
    if (*__first2 < *__first1)
      return 1;
    ++__first1;
    ++__first2;
  }
  if (__first2 == __last2) {
    return !(__first1 == __last1);
  }
  else {
    return -1;
  }
}

inline int
__lexicographical_compare_3way(const unsigned char* __first1,
                               const unsigned char* __last1,
                               const unsigned char* __first2,
                               const unsigned char* __last2)
{
  const ptrdiff_t __len1 = __last1 - __first1;
  const ptrdiff_t __len2 = __last2 - __first2;
  const int __result = memcmp(__first1, __first2, min(__len1, __len2));
  return __result != 0 ? __result
                       : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
}

inline int
__lexicographical_compare_3way(const char* __first1, const char* __last1,
                               const char* __first2, const char* __last2)
{

  return __lexicographical_compare_3way(
                                (const signed char*) __first1,
                                (const signed char*) __last1,
                                (const signed char*) __first2,
                                (const signed char*) __last2);






}

template <class _InputIter1, class _InputIter2>
int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
                                 _InputIter2 __first2, _InputIter2 __last2)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


  return __lexicographical_compare_3way(__first1, __last1, __first2, __last2);
}

}
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 1 3
# 57 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception_defines.h" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 58 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 59 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 1 3
# 60 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 1 3
# 61 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cassert.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cassert.h" 3
# 1 "/usr/include/assert.h" 1 3 4
# 11 "/usr/include/assert.h" 3 4
#pragma ident "@(#)assert.h	1.9	92/07/14 SMI"


extern "C" {



extern void __assert(const char *, const char *, int);





}
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cassert.h" 2 3
# 62 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 2 3





# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 1 3
# 62 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/gthr.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 2 3
# 80 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
namespace std
{
# 95 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
struct _Refcount_Base
{




  typedef size_t _RC_t;



   volatile _RC_t _M_ref_count;




  __gthread_mutex_t _M_ref_count_lock;
  _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
    {

      __gthread_mutex_t __tmp = {{0, 0, 0, 0}, {{{0}}}, 0};
      _M_ref_count_lock = __tmp;





    }
# 141 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
  void _M_incr() {
    __gthread_mutex_lock(&_M_ref_count_lock);
    ++_M_ref_count;
    __gthread_mutex_unlock(&_M_ref_count_lock);
  }
  _RC_t _M_decr() {
    __gthread_mutex_lock(&_M_ref_count_lock);
    volatile _RC_t __tmp = --_M_ref_count;
    __gthread_mutex_unlock(&_M_ref_count_lock);
    return __tmp;
  }
# 192 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
};
# 313 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
template <int __inst>
struct _STL_mutex_spin {
  enum { __low_max = 30, __high_max = 1000 };


  static unsigned __max;
  static unsigned __last;
};

template <int __inst>
unsigned _STL_mutex_spin<__inst>::__max = _STL_mutex_spin<__inst>::__low_max;

template <int __inst>
unsigned _STL_mutex_spin<__inst>::__last = 0;
# 340 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
struct _STL_mutex_lock
{







  __gthread_mutex_t _M_lock;
  void _M_initialize() {
# 371 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
  }
  void _M_acquire_lock() {



    __gthread_mutex_lock(&_M_lock);
  }
  void _M_release_lock() {



    __gthread_mutex_unlock(&_M_lock);
  }
# 482 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
};
# 521 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_threads.h" 3
struct _STL_auto_lock
{
  _STL_mutex_lock& _M_lock;

  _STL_auto_lock(_STL_mutex_lock& __lock) : _M_lock(__lock)
    { _M_lock._M_acquire_lock(); }
  ~_STL_auto_lock() { _M_lock._M_release_lock(); }

private:
  void operator=(const _STL_auto_lock&);
  _STL_auto_lock(const _STL_auto_lock&);
};

}
# 68 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 2 3
# 97 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 3
namespace std
{



template <int __inst>
class __malloc_alloc_template {

private:

  static void* _S_oom_malloc(size_t);
  static void* _S_oom_realloc(void*, size_t);
  static void (* __malloc_alloc_oom_handler)();

public:

  static void* allocate(size_t __n)
  {
    void* __result = malloc(__n);
    if (0 == __result) __result = _S_oom_malloc(__n);
    return __result;
  }

  static void deallocate(void* __p, size_t )
  {
    free(__p);
  }

  static void* reallocate(void* __p, size_t , size_t __new_sz)
  {
    void* __result = realloc(__p, __new_sz);
    if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
    return __result;
  }

  static void (* __set_malloc_handler(void (*__f)()))()
  {
    void (* __old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = __f;
    return(__old);
  }

};



template <int __inst>
void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;

template <int __inst>
void*
__malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n)
{
    void (* __my_malloc_handler)();
    void* __result;

    for (;;) {
        __my_malloc_handler = __malloc_alloc_oom_handler;
        if (0 == __my_malloc_handler) { std::__throw_bad_alloc(); }
        (*__my_malloc_handler)();
        __result = malloc(__n);
        if (__result) return(__result);
    }
}

template <int __inst>
void* __malloc_alloc_template<__inst>::_S_oom_realloc(void* __p, size_t __n)
{
    void (* __my_malloc_handler)();
    void* __result;

    for (;;) {
        __my_malloc_handler = __malloc_alloc_oom_handler;
        if (0 == __my_malloc_handler) { std::__throw_bad_alloc(); }
        (*__my_malloc_handler)();
        __result = realloc(__p, __n);
        if (__result) return(__result);
    }
}

typedef __malloc_alloc_template<0> malloc_alloc;

template<class _Tp, class _Alloc>
class simple_alloc {

public:
    static _Tp* allocate(size_t __n)
      { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
    static _Tp* allocate(void)
      { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
    static void deallocate(_Tp* __p, size_t __n)
      { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
    static void deallocate(_Tp* __p)
      { _Alloc::deallocate(__p, sizeof (_Tp)); }
};






template <class _Alloc>
class debug_alloc {

private:

  enum {_S_extra = 8};



public:

  static void* allocate(size_t __n)
  {
    char* __result = (char*)_Alloc::allocate(__n + (int) _S_extra);
    *(size_t*)__result = __n;
    return __result + (int) _S_extra;
  }

  static void deallocate(void* __p, size_t __n)
  {
    char* __real_p = (char*)__p - (int) _S_extra;
    (void)((*(size_t*)__real_p == __n) || (__assert("*(size_t*)__real_p == __n", "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h", 219), 0));
    _Alloc::deallocate(__real_p, __n + (int) _S_extra);
  }

  static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz)
  {
    char* __real_p = (char*)__p - (int) _S_extra;
    (void)((*(size_t*)__real_p == __old_sz) || (__assert("*(size_t*)__real_p == __old_sz", "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h", 226), 0));
    char* __result = (char*)
      _Alloc::reallocate(__real_p, __old_sz + (int) _S_extra,
                                   __new_sz + (int) _S_extra);
    *(size_t*)__result = __new_sz;
    return __result + (int) _S_extra;
  }

};
# 270 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 3
template <bool threads, int inst>
class __default_alloc_template {

private:


  enum {_ALIGN = 8};
  enum {_MAX_BYTES = 128};
  enum {_NFREELISTS = 16};
  static size_t
  _S_round_up(size_t __bytes)
    { return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }

  union _Obj {
        union _Obj* _M_free_list_link;
        char _M_client_data[1];
  };

  static _Obj* volatile _S_free_list[];

  static size_t _S_freelist_index(size_t __bytes) {
        return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1);
  }


  static void* _S_refill(size_t __n);


  static char* _S_chunk_alloc(size_t __size, int& __nobjs);


  static char* _S_start_free;
  static char* _S_end_free;
  static size_t _S_heap_size;


    static _STL_mutex_lock _S_node_allocator_lock;





    class _Lock;
    friend class _Lock;
    class _Lock {
        public:
            _Lock() { { if (threads) _S_node_allocator_lock._M_acquire_lock(); }; }
            ~_Lock() { { if (threads) _S_node_allocator_lock._M_release_lock(); }; }
    };

public:


  static void* allocate(size_t __n)
  {
    void* __ret = 0;

    if (__n > (size_t) _MAX_BYTES) {
      __ret = malloc_alloc::allocate(__n);
    }
    else {
      _Obj* volatile* __my_free_list
          = _S_free_list + _S_freelist_index(__n);





      _Lock __lock_instance;

      _Obj* __result = *__my_free_list;
      if (__result == 0)
        __ret = _S_refill(_S_round_up(__n));
      else {
        *__my_free_list = __result -> _M_free_list_link;
        __ret = __result;
      }
    }

    return __ret;
  };


  static void deallocate(void* __p, size_t __n)
  {
    if (__n > (size_t) _MAX_BYTES)
      malloc_alloc::deallocate(__p, __n);
    else {
      _Obj* volatile* __my_free_list
          = _S_free_list + _S_freelist_index(__n);
      _Obj* __q = (_Obj*)__p;




      _Lock __lock_instance;

      __q -> _M_free_list_link = *__my_free_list;
      *__my_free_list = __q;

    }
  }

  static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz);

} ;

typedef __default_alloc_template<true, 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;

template <bool __threads, int __inst>
inline bool operator==(const __default_alloc_template<__threads, __inst>&,
                       const __default_alloc_template<__threads, __inst>&)
{
  return true;
}

template <bool __threads, int __inst>
inline bool operator!=(const __default_alloc_template<__threads, __inst>&,
                       const __default_alloc_template<__threads, __inst>&)
{
  return false;
}







template <bool __threads, int __inst>
char*
__default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size,
                                                            int& __nobjs)
{
    char* __result;
    size_t __total_bytes = __size * __nobjs;
    size_t __bytes_left = _S_end_free - _S_start_free;

    if (__bytes_left >= __total_bytes) {
        __result = _S_start_free;
        _S_start_free += __total_bytes;
        return(__result);
    } else if (__bytes_left >= __size) {
        __nobjs = (int)(__bytes_left/__size);
        __total_bytes = __size * __nobjs;
        __result = _S_start_free;
        _S_start_free += __total_bytes;
        return(__result);
    } else {
        size_t __bytes_to_get =
          2 * __total_bytes + _S_round_up(_S_heap_size >> 4);

        if (__bytes_left > 0) {
            _Obj* volatile* __my_free_list =
                        _S_free_list + _S_freelist_index(__bytes_left);

            ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
            *__my_free_list = (_Obj*)_S_start_free;
        }
        _S_start_free = (char*)malloc(__bytes_to_get);
        if (0 == _S_start_free) {
            size_t __i;
            _Obj* volatile* __my_free_list;
            _Obj* __p;



            for (__i = __size;
                 __i <= (size_t) _MAX_BYTES;
                 __i += (size_t) _ALIGN) {
                __my_free_list = _S_free_list + _S_freelist_index(__i);
                __p = *__my_free_list;
                if (0 != __p) {
                    *__my_free_list = __p -> _M_free_list_link;
                    _S_start_free = (char*)__p;
                    _S_end_free = _S_start_free + __i;
                    return(_S_chunk_alloc(__size, __nobjs));


                }
            }
            _S_end_free = 0;
            _S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);



        }
        _S_heap_size += __bytes_to_get;
        _S_end_free = _S_start_free + __bytes_to_get;
        return(_S_chunk_alloc(__size, __nobjs));
    }
}





template <bool __threads, int __inst>
void*
__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
{
    int __nobjs = 20;
    char* __chunk = _S_chunk_alloc(__n, __nobjs);
    _Obj* volatile* __my_free_list;
    _Obj* __result;
    _Obj* __current_obj;
    _Obj* __next_obj;
    int __i;

    if (1 == __nobjs) return(__chunk);
    __my_free_list = _S_free_list + _S_freelist_index(__n);


      __result = (_Obj*)__chunk;
      *__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
      for (__i = 1; ; __i++) {
        __current_obj = __next_obj;
        __next_obj = (_Obj*)((char*)__next_obj + __n);
        if (__nobjs - 1 == __i) {
            __current_obj -> _M_free_list_link = 0;
            break;
        } else {
            __current_obj -> _M_free_list_link = __next_obj;
        }
      }
    return(__result);
}

template <bool threads, int inst>
void*
__default_alloc_template<threads, inst>::reallocate(void* __p,
                                                    size_t __old_sz,
                                                    size_t __new_sz)
{
    void* __result;
    size_t __copy_sz;

    if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES) {
        return(realloc(__p, __new_sz));
    }
    if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p);
    __result = allocate(__new_sz);
    __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
    memcpy(__result, __p, __copy_sz);
    deallocate(__p, __old_sz);
    return(__result);
}


    template <bool __threads, int __inst>
    _STL_mutex_lock
    __default_alloc_template<__threads, __inst>::_S_node_allocator_lock
        = { {{0, 0, 0, 0}, {{{0}}}, 0} };



template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_start_free = 0;

template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_end_free = 0;

template <bool __threads, int __inst>
size_t __default_alloc_template<__threads, __inst>::_S_heap_size = 0;

template <bool __threads, int __inst>
typename __default_alloc_template<__threads, __inst>::_Obj* volatile
__default_alloc_template<__threads, __inst> ::_S_free_list[
    __default_alloc_template<__threads, __inst>::_NFREELISTS
] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
# 555 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp>
class allocator {
  typedef alloc _Alloc;
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef _Tp* pointer;
  typedef const _Tp* const_pointer;
  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() throw() {}
  allocator(const allocator&) throw() {}
  template <class _Tp1> allocator(const allocator<_Tp1>&) throw() {}
  ~allocator() throw() {}

  pointer address(reference __x) const { return &__x; }
  const_pointer address(const_reference __x) const { return &__x; }



  _Tp* allocate(size_type __n, const void* = 0) {
    return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)))
                    : 0;
  }


  void deallocate(pointer __p, size_type __n)
    { _Alloc::deallocate(__p, __n * sizeof(_Tp)); }

  size_type max_size() const throw()
    { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
  void destroy(pointer __p) { __p->~_Tp(); }
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};


template <class _T1, class _T2>
inline bool operator==(const allocator<_T1>&, const allocator<_T2>&)
{
  return true;
}

template <class _T1, class _T2>
inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&)
{
  return false;
}
# 631 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp, class _Alloc>
struct __allocator {
  _Alloc __underlying_alloc;

  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef _Tp* pointer;
  typedef const _Tp* const_pointer;
  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef __allocator<_Tp1, _Alloc> other;
  };

  __allocator() throw() {}
  __allocator(const __allocator& __a) throw()
    : __underlying_alloc(__a.__underlying_alloc) {}
  template <class _Tp1>
  __allocator(const __allocator<_Tp1, _Alloc>& __a) throw()
    : __underlying_alloc(__a.__underlying_alloc) {}
  ~__allocator() throw() {}

  pointer address(reference __x) const { return &__x; }
  const_pointer address(const_reference __x) const { return &__x; }


  _Tp* allocate(size_type __n, const void* = 0) {
    return __n != 0
        ? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp)))
        : 0;
  }


  void deallocate(pointer __p, size_type __n)
    { __underlying_alloc.deallocate(__p, __n * sizeof(_Tp)); }

  size_type max_size() const throw()
    { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
  void destroy(pointer __p) { __p->~_Tp(); }
};

template <class _Alloc>
class __allocator<void, _Alloc> {
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef __allocator<_Tp1, _Alloc> other;
  };
};

template <class _Tp, class _Alloc>
inline bool operator==(const __allocator<_Tp, _Alloc>& __a1,
                       const __allocator<_Tp, _Alloc>& __a2)
{
  return __a1.__underlying_alloc == __a2.__underlying_alloc;
}

template <class _Tp, class _Alloc>
inline bool operator!=(const __allocator<_Tp, _Alloc>& __a1,
                       const __allocator<_Tp, _Alloc>& __a2)
{
  return __a1.__underlying_alloc != __a2.__underlying_alloc;
}





template <int inst>
inline bool operator==(const __malloc_alloc_template<inst>&,
                       const __malloc_alloc_template<inst>&)
{
  return true;
}

template <int __inst>
inline bool operator!=(const __malloc_alloc_template<__inst>&,
                       const __malloc_alloc_template<__inst>&)
{
  return false;
}

template <class _Alloc>
inline bool operator==(const debug_alloc<_Alloc>&,
                       const debug_alloc<_Alloc>&) {
  return true;
}

template <class _Alloc>
inline bool operator!=(const debug_alloc<_Alloc>&,
                       const debug_alloc<_Alloc>&) {
  return false;
}
# 761 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp, class _Allocator>
struct _Alloc_traits
{
  static const bool _S_instanceless = false;
  typedef typename _Allocator::template rebind<_Tp>::other allocator_type;
};

template <class _Tp, class _Allocator>
const bool _Alloc_traits<_Tp, _Allocator>::_S_instanceless;



template <class _Tp, class _Tp1>
struct _Alloc_traits<_Tp, allocator<_Tp1> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, alloc> _Alloc_type;
  typedef allocator<_Tp> allocator_type;
};



template <class _Tp, int __inst>
struct _Alloc_traits<_Tp, __malloc_alloc_template<__inst> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
  typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
};


template <class _Tp, bool __threads, int __inst>
struct _Alloc_traits<_Tp, __default_alloc_template<__threads, __inst> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, __default_alloc_template<__threads, __inst> >
          _Alloc_type;
  typedef __allocator<_Tp, __default_alloc_template<__threads, __inst> >
          allocator_type;
};


template <class _Tp, class _Alloc>
struct _Alloc_traits<_Tp, debug_alloc<_Alloc> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
  typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
};




template <class _Tp, class _Tp1, int __inst>
struct _Alloc_traits<_Tp,
                     __allocator<_Tp1, __malloc_alloc_template<__inst> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
  typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
};


template <class _Tp, class _Tp1, bool __thr, int __inst>
struct _Alloc_traits<_Tp,
                      __allocator<_Tp1,
                                  __default_alloc_template<__thr, __inst> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, __default_alloc_template<__thr,__inst> >
          _Alloc_type;
  typedef __allocator<_Tp, __default_alloc_template<__thr,__inst> >
          allocator_type;
};


template <class _Tp, class _Tp1, class _Alloc>
struct _Alloc_traits<_Tp, __allocator<_Tp1, debug_alloc<_Alloc> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
  typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
};

}
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_construct.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_construct.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/new" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_construct.h" 2 3

namespace std
{
# 76 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_construct.h" 3
template <class _T1, class _T2>
inline void _Construct(_T1* __p, const _T2& __value) {
new ((void*) __p) _T1(__value);
}

template <class _T1>
inline void _Construct(_T1* __p) {
  new ((void*) __p) _T1();
}

template <class _Tp>
inline void _Destroy(_Tp* __pointer) {
  __pointer->~_Tp();
}

template <class _ForwardIterator>
void
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
{
  for ( ; __first != __last; ++__first)
    destroy(&*__first);
}

template <class _ForwardIterator>
inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}

template <class _ForwardIterator, class _Tp>
inline void
__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
{
  typedef typename __type_traits<_Tp>::has_trivial_destructor
          _Trivial_destructor;
  __destroy_aux(__first, __last, _Trivial_destructor());
}

template <class _ForwardIterator>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
  __destroy(__first, __last, __value_type(__first));
}

inline void _Destroy(char*, char*) {}
inline void _Destroy(int*, int*) {}
inline void _Destroy(long*, long*) {}
inline void _Destroy(float*, float*) {}
inline void _Destroy(double*, double*) {}
inline void _Destroy(wchar_t*, wchar_t*) {}




template <class _T1, class _T2>
inline void construct(_T1* __p, const _T2& __value) {
  _Construct(__p, __value);
}

template <class _T1>
inline void construct(_T1* __p) {
  _Construct(__p);
}

template <class _Tp>
inline void destroy(_Tp* __pointer) {
  _Destroy(__pointer);
}

template <class _ForwardIterator>
inline void destroy(_ForwardIterator __first, _ForwardIterator __last) {
  _Destroy(__first, __last);
}

}
# 65 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_uninitialized.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_uninitialized.h" 2 3

namespace std
{





template <class _InputIter, class _ForwardIter>
inline _ForwardIter
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
                         _ForwardIter __result,
                         __true_type)
{
  return copy(__first, __last, __result);
}

template <class _InputIter, class _ForwardIter>
_ForwardIter
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
                         _ForwardIter __result,
                         __false_type)
{
  _ForwardIter __cur = __result;
  try {
    for ( ; __first != __last; ++__first, ++__cur)
      _Construct(&*__cur, *__first);
    return __cur;
  }
  catch(...) { _Destroy(__result, __cur); throw; };
}


template <class _InputIter, class _ForwardIter, class _Tp>
inline _ForwardIter
__uninitialized_copy(_InputIter __first, _InputIter __last,
                     _ForwardIter __result, _Tp*)
{
  typedef typename __type_traits<_Tp>::is_POD_type _Is_POD;
  return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
}

template <class _InputIter, class _ForwardIter>
inline _ForwardIter
  uninitialized_copy(_InputIter __first, _InputIter __last,
                     _ForwardIter __result)
{
  return __uninitialized_copy(__first, __last, __result,
                              __value_type(__result));
}

inline char* uninitialized_copy(const char* __first, const char* __last,
                                char* __result) {
  memmove(__result, __first, __last - __first);
  return __result + (__last - __first);
}

inline wchar_t*
uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
                   wchar_t* __result)
{
  memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
  return __result + (__last - __first);
}



template <class _InputIter, class _Size, class _ForwardIter>
pair<_InputIter, _ForwardIter>
__uninitialized_copy_n(_InputIter __first, _Size __count,
                       _ForwardIter __result,
                       input_iterator_tag)
{
  _ForwardIter __cur = __result;
  try {
    for ( ; __count > 0 ; --__count, ++__first, ++__cur)
      _Construct(&*__cur, *__first);
    return pair<_InputIter, _ForwardIter>(__first, __cur);
  }
  catch(...) { _Destroy(__result, __cur); throw; };
}

template <class _RandomAccessIter, class _Size, class _ForwardIter>
inline pair<_RandomAccessIter, _ForwardIter>
__uninitialized_copy_n(_RandomAccessIter __first, _Size __count,
                       _ForwardIter __result,
                       random_access_iterator_tag) {
  _RandomAccessIter __last = __first + __count;
  return pair<_RandomAccessIter, _ForwardIter>(
                 __last,
                 uninitialized_copy(__first, __last, __result));
}

template <class _InputIter, class _Size, class _ForwardIter>
inline pair<_InputIter, _ForwardIter>
__uninitialized_copy_n(_InputIter __first, _Size __count,
                     _ForwardIter __result) {
  return __uninitialized_copy_n(__first, __count, __result,
                                __iterator_category(__first));
}

template <class _InputIter, class _Size, class _ForwardIter>
inline pair<_InputIter, _ForwardIter>
uninitialized_copy_n(_InputIter __first, _Size __count,
                     _ForwardIter __result) {
  return __uninitialized_copy_n(__first, __count, __result,
                                __iterator_category(__first));
}



template <class _ForwardIter, class _Tp>
inline void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
                         const _Tp& __x, __true_type)
{
  fill(__first, __last, __x);
}

template <class _ForwardIter, class _Tp>
void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
                         const _Tp& __x, __false_type)
{
  _ForwardIter __cur = __first;
  try {
    for ( ; __cur != __last; ++__cur)
      _Construct(&*__cur, __x);
  }
  catch(...) { _Destroy(__first, __cur); throw; };
}

template <class _ForwardIter, class _Tp, class _Tp1>
inline void __uninitialized_fill(_ForwardIter __first,
                                 _ForwardIter __last, const _Tp& __x, _Tp1*)
{
  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  __uninitialized_fill_aux(__first, __last, __x, _Is_POD());

}

template <class _ForwardIter, class _Tp>
inline void uninitialized_fill(_ForwardIter __first,
                               _ForwardIter __last,
                               const _Tp& __x)
{
  __uninitialized_fill(__first, __last, __x, __value_type(__first));
}



template <class _ForwardIter, class _Size, class _Tp>
inline _ForwardIter
__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
                           const _Tp& __x, __true_type)
{
  return fill_n(__first, __n, __x);
}

template <class _ForwardIter, class _Size, class _Tp>
_ForwardIter
__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
                           const _Tp& __x, __false_type)
{
  _ForwardIter __cur = __first;
  try {
    for ( ; __n > 0; --__n, ++__cur)
      _Construct(&*__cur, __x);
    return __cur;
  }
  catch(...) { _Destroy(__first, __cur); throw; };
}

template <class _ForwardIter, class _Size, class _Tp, class _Tp1>
inline _ForwardIter
__uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x, _Tp1*)
{
  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
}

template <class _ForwardIter, class _Size, class _Tp>
inline _ForwardIter
uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
{
  return __uninitialized_fill_n(__first, __n, __x, __value_type(__first));
}
# 260 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_uninitialized.h" 3
template <class _InputIter1, class _InputIter2, class _ForwardIter>
inline _ForwardIter
__uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
                          _InputIter2 __first2, _InputIter2 __last2,
                          _ForwardIter __result)
{
  _ForwardIter __mid = uninitialized_copy(__first1, __last1, __result);
  try {
    return uninitialized_copy(__first2, __last2, __mid);
  }
  catch(...) { _Destroy(__result, __mid); throw; };
}




template <class _ForwardIter, class _Tp, class _InputIter>
inline _ForwardIter
__uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid,
                          const _Tp& __x,
                          _InputIter __first, _InputIter __last)
{
  uninitialized_fill(__result, __mid, __x);
  try {
    return uninitialized_copy(__first, __last, __mid);
  }
  catch(...) { _Destroy(__result, __mid); throw; };
}




template <class _InputIter, class _ForwardIter, class _Tp>
inline void
__uninitialized_copy_fill(_InputIter __first1, _InputIter __last1,
                          _ForwardIter __first2, _ForwardIter __last2,
                          const _Tp& __x)
{
  _ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2);
  try {
    uninitialized_fill(__mid2, __last2, __x);
  }
  catch(...) { _Destroy(__first2, __mid2); throw; };
}

}
# 66 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_vector.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_vector.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_funcs.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception_defines.h" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 65 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/concept_check.h" 1 3
# 66 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_vector.h" 2 3

namespace std
{
# 77 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_vector.h" 3
template <class _Tp, class _Allocator, bool _IsStatic>
class _Vector_alloc_base {
public:
  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return _M_data_allocator; }

  _Vector_alloc_base(const allocator_type& __a)
    : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
  {}

protected:
  allocator_type _M_data_allocator;
  _Tp* _M_start;
  _Tp* _M_finish;
  _Tp* _M_end_of_storage;

  _Tp* _M_allocate(size_t __n)
    { return _M_data_allocator.allocate(__n); }
  void _M_deallocate(_Tp* __p, size_t __n)
    { if (__p) _M_data_allocator.deallocate(__p, __n); }
};



template <class _Tp, class _Allocator>
class _Vector_alloc_base<_Tp, _Allocator, true> {
public:
  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _Vector_alloc_base(const allocator_type&)
    : _M_start(0), _M_finish(0), _M_end_of_storage(0)
  {}

protected:
  _Tp* _M_start;
  _Tp* _M_finish;
  _Tp* _M_end_of_storage;

  typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type;
  _Tp* _M_allocate(size_t __n)
    { return _Alloc_type::allocate(__n); }
  void _M_deallocate(_Tp* __p, size_t __n)
    { _Alloc_type::deallocate(__p, __n);}
};

template <class _Tp, class _Alloc>
struct _Vector_base
  : public _Vector_alloc_base<_Tp, _Alloc,
                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
{
  typedef _Vector_alloc_base<_Tp, _Alloc,
                             _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
          _Base;
  typedef typename _Base::allocator_type allocator_type;

  _Vector_base(const allocator_type& __a) : _Base(__a) {}
  _Vector_base(size_t __n, const allocator_type& __a) : _Base(__a) {
    _M_start = _M_allocate(__n);
    _M_finish = _M_start;
    _M_end_of_storage = _M_start + __n;
  }

  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
};


template <class _Tp, class _Alloc = allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc>
{

                                                      ;

private:
  typedef _Vector_base<_Tp, _Alloc> _Base;
  typedef vector<_Tp, _Alloc> vector_type;
public:
  typedef _Tp value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef __normal_iterator<pointer, vector_type> iterator;
  typedef __normal_iterator<const_pointer, vector_type> const_iterator;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }

  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;

protected:
  using _Base::_M_allocate;
  using _Base::_M_deallocate;
  using _Base::_M_start;
  using _Base::_M_finish;
  using _Base::_M_end_of_storage;

protected:
  void _M_insert_aux(iterator __position, const _Tp& __x);
  void _M_insert_aux(iterator __position);

public:
  iterator begin() { return iterator (_M_start); }
  const_iterator begin() const
    { return const_iterator (_M_start); }
  iterator end() { return iterator (_M_finish); }
  const_iterator end() const { return const_iterator (_M_finish); }

  reverse_iterator rbegin()
    { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const
    { return const_reverse_iterator(end()); }
  reverse_iterator rend()
    { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const
    { return const_reverse_iterator(begin()); }

  size_type size() const
    { return size_type(end() - begin()); }
  size_type max_size() const
    { return size_type(-1) / sizeof(_Tp); }
  size_type capacity() const
    { return size_type(const_iterator(_M_end_of_storage) - begin()); }
  bool empty() const
    { return begin() == end(); }

  reference operator[](size_type __n) { return *(begin() + __n); }
  const_reference operator[](size_type __n) const { return *(begin() + __n); }

  void _M_range_check(size_type __n) const {
    if (__n >= this->size())
      __throw_out_of_range("vector");
  }

  reference at(size_type __n)
    { _M_range_check(__n); return (*this)[__n]; }
  const_reference at(size_type __n) const
    { _M_range_check(__n); return (*this)[__n]; }

  explicit vector(const allocator_type& __a = allocator_type())
    : _Base(__a) {}

  vector(size_type __n, const _Tp& __value,
         const allocator_type& __a = allocator_type())
    : _Base(__n, __a)
    { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }

  explicit vector(size_type __n)
    : _Base(__n, allocator_type())
    { _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); }

  vector(const vector<_Tp, _Alloc>& __x)
    : _Base(__x.size(), __x.get_allocator())
    { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }


  template <class _InputIterator>
  vector(_InputIterator __first, _InputIterator __last,
         const allocator_type& __a = allocator_type()) : _Base(__a) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_initialize_aux(__first, __last, _Integral());
  }

  template <class _Integer>
  void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {
    _M_start = _M_allocate(__n);
    _M_end_of_storage = _M_start + __n;
    _M_finish = uninitialized_fill_n(_M_start, __n, __value);
  }

  template <class _InputIterator>
  void _M_initialize_aux(_InputIterator __first, _InputIterator __last,
                         __false_type) {
    _M_range_initialize(__first, __last, __iterator_category(__first));
  }

  ~vector() { destroy(_M_start, _M_finish); }

  vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x);
  void reserve(size_type __n) {
    if (capacity() < __n) {
      const size_type __old_size = size();
      pointer __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);
      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __tmp;
      _M_finish = __tmp + __old_size;
      _M_end_of_storage = _M_start + __n;
    }
  }






  void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }
  void _M_fill_assign(size_type __n, const _Tp& __val);

  template <class _InputIterator>
  void assign(_InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_assign_dispatch(__first, __last, _Integral());
  }

  template <class _Integer>
  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
    { _M_fill_assign((size_type) __n, (_Tp) __val); }

  template <class _InputIter>
  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
    { _M_assign_aux(__first, __last, __iterator_category(__first)); }

  template <class _InputIterator>
  void _M_assign_aux(_InputIterator __first, _InputIterator __last,
                     input_iterator_tag);

  template <class _ForwardIterator>
  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                     forward_iterator_tag);

  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(end() - 1); }
  const_reference back() const { return *(end() - 1); }

  void push_back(const _Tp& __x) {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
      _M_insert_aux(end(), __x);
  }
  void push_back() {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish);
      ++_M_finish;
    }
    else
      _M_insert_aux(end());
  }
  void swap(vector<_Tp, _Alloc>& __x) {
    std::swap(_M_start, __x._M_start);
    std::swap(_M_finish, __x._M_finish);
    std::swap(_M_end_of_storage, __x._M_end_of_storage);
  }

  iterator insert(iterator __position, const _Tp& __x) {
    size_type __n = __position - begin();
    if (_M_finish != _M_end_of_storage && __position == end()) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
      _M_insert_aux(iterator(__position), __x);
    return begin() + __n;
  }
  iterator insert(iterator __position) {
    size_type __n = __position - begin();
    if (_M_finish != _M_end_of_storage && __position == end()) {
      construct(_M_finish);
      ++_M_finish;
    }
    else
      _M_insert_aux(iterator(__position));
    return begin() + __n;
  }

  template <class _InputIterator>
  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_insert_dispatch(__pos, __first, __last, _Integral());
  }

  template <class _Integer>
  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
                          __true_type)
    { _M_fill_insert(__pos, (size_type) __n, (_Tp) __val); }

  template <class _InputIterator>
  void _M_insert_dispatch(iterator __pos,
                          _InputIterator __first, _InputIterator __last,
                          __false_type) {
    _M_range_insert(__pos, __first, __last, __iterator_category(__first));
  }

  void insert (iterator __pos, size_type __n, const _Tp& __x)
    { _M_fill_insert(__pos, __n, __x); }

  void _M_fill_insert (iterator __pos, size_type __n, const _Tp& __x);

  void pop_back() {
    --_M_finish;
    destroy(_M_finish);
  }
  iterator erase(iterator __position) {
    if (__position + 1 != end())
      copy(__position + 1, end(), __position);
    --_M_finish;
    destroy(_M_finish);
    return __position;
  }
  iterator erase(iterator __first, iterator __last) {
    iterator __i(copy(__last, end(), __first));
    destroy(__i, end());
    _M_finish = _M_finish - (__last - __first);
    return __first;
  }

  void resize(size_type __new_size, const _Tp& __x) {
    if (__new_size < size())
      erase(begin() + __new_size, end());
    else
      insert(end(), __new_size - size(), __x);
  }
  void resize(size_type __new_size) { resize(__new_size, _Tp()); }
  void clear() { erase(begin(), end()); }

protected:

  template <class _ForwardIterator>
  pointer _M_allocate_and_copy(size_type __n, _ForwardIterator __first,
                                               _ForwardIterator __last)
  {
    pointer __result = _M_allocate(__n);
    try {
      uninitialized_copy(__first, __last, __result);
      return __result;
    }
    catch(...) { _M_deallocate(__result, __n); throw; };
  }

  template <class _InputIterator>
  void _M_range_initialize(_InputIterator __first,
                           _InputIterator __last, input_iterator_tag)
  {
    for ( ; __first != __last; ++__first)
      push_back(*__first);
  }


  template <class _ForwardIterator>
  void _M_range_initialize(_ForwardIterator __first,
                           _ForwardIterator __last, forward_iterator_tag)
  {
    size_type __n = 0;
    distance(__first, __last, __n);
    _M_start = _M_allocate(__n);
    _M_end_of_storage = _M_start + __n;
    _M_finish = uninitialized_copy(__first, __last, _M_start);
  }

  template <class _InputIterator>
  void _M_range_insert(iterator __pos,
                       _InputIterator __first, _InputIterator __last,
                       input_iterator_tag);

  template <class _ForwardIterator>
  void _M_range_insert(iterator __pos,
                       _ForwardIterator __first, _ForwardIterator __last,
                       forward_iterator_tag);
};

template <class _Tp, class _Alloc>
inline bool
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{
  return __x.size() == __y.size() &&
         equal(__x.begin(), __x.end(), __y.begin());
}

template <class _Tp, class _Alloc>
inline bool
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{
  return lexicographical_compare(__x.begin(), __x.end(),
                                 __y.begin(), __y.end());
}

template <class _Tp, class _Alloc>
inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{
  __x.swap(__y);
}

template <class _Tp, class _Alloc>
inline bool
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return !(__x == __y);
}

template <class _Tp, class _Alloc>
inline bool
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return __y < __x;
}

template <class _Tp, class _Alloc>
inline bool
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return !(__y < __x);
}

template <class _Tp, class _Alloc>
inline bool
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return !(__x < __y);
}

template <class _Tp, class _Alloc>
vector<_Tp,_Alloc>&
vector<_Tp,_Alloc>::operator=(const vector<_Tp, _Alloc>& __x)
{
  if (&__x != this) {
    const size_type __xlen = __x.size();
    if (__xlen > capacity()) {
      pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());
      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __tmp;
      _M_end_of_storage = _M_start + __xlen;
    }
    else if (size() >= __xlen) {
      iterator __i(copy(__x.begin(), __x.end(), begin()));
      destroy(__i, end());
    }
    else {
      copy(__x.begin(), __x.begin() + size(), _M_start);
      uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish);
    }
    _M_finish = _M_start + __xlen;
  }
  return *this;
}

template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const value_type& __val)
{
  if (__n > capacity()) {
    vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
    __tmp.swap(*this);
  }
  else if (__n > size()) {
    fill(begin(), end(), __val);
    _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val);
  }
  else
    erase(fill_n(begin(), __n, __val), end());
}

template <class _Tp, class _Alloc> template <class _InputIter>
void vector<_Tp, _Alloc>::_M_assign_aux(_InputIter __first, _InputIter __last,
                                        input_iterator_tag) {
  iterator __cur(begin());
  for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
    *__cur = *__first;
  if (__first == __last)
    erase(__cur, end());
  else
    insert(end(), __first, __last);
}

template <class _Tp, class _Alloc> template <class _ForwardIter>
void
vector<_Tp, _Alloc>::_M_assign_aux(_ForwardIter __first, _ForwardIter __last,
                                   forward_iterator_tag) {
  size_type __len = 0;
  distance(__first, __last, __len);

  if (__len > capacity()) {
    pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
    destroy(_M_start, _M_finish);
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __tmp;
    _M_end_of_storage = _M_finish = _M_start + __len;
  }
  else if (size() >= __len) {
    iterator __new_finish(copy(__first, __last, _M_start));
    destroy(__new_finish, end());
    _M_finish = __new_finish.base();
  }
  else {
    _ForwardIter __mid = __first;
    advance(__mid, size());
    copy(__first, __mid, _M_start);
    _M_finish = uninitialized_copy(__mid, __last, _M_finish);
  }
}

template <class _Tp, class _Alloc>
void
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
  if (_M_finish != _M_end_of_storage) {
    construct(_M_finish, *(_M_finish - 1));
    ++_M_finish;
    _Tp __x_copy = __x;
    copy_backward(__position, iterator(_M_finish - 2), iterator(_M_finish- 1));
    *__position = __x_copy;
  }
  else {
    const size_type __old_size = size();
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
    iterator __new_start(_M_allocate(__len));
    iterator __new_finish(__new_start);
    try {
      __new_finish = uninitialized_copy(iterator(_M_start), __position,
                                        __new_start);
      construct(__new_finish.base(), __x);
      ++__new_finish;
      __new_finish = uninitialized_copy(__position, iterator(_M_finish),
                                        __new_finish);
    }
    catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start.base(),__len)); throw; };

    destroy(begin(), end());
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __new_start.base();
    _M_finish = __new_finish.base();
    _M_end_of_storage = __new_start.base() + __len;
  }
}

template <class _Tp, class _Alloc>
void
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position)
{
  if (_M_finish != _M_end_of_storage) {
    construct(_M_finish, *(_M_finish - 1));
    ++_M_finish;
    copy_backward(__position, iterator(_M_finish - 2),
                  iterator(_M_finish - 1));
    *__position = _Tp();
  }
  else {
    const size_type __old_size = size();
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
    pointer __new_start = _M_allocate(__len);
    pointer __new_finish = __new_start;
    try {
      __new_finish = uninitialized_copy(iterator(_M_start), __position,
                                        __new_start);
      construct(__new_finish);
      ++__new_finish;
      __new_finish = uninitialized_copy(__position, iterator(_M_finish),
                                        __new_finish);
    }
    catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start,__len)); throw; };

    destroy(begin(), end());
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __new_start;
    _M_finish = __new_finish;
    _M_end_of_storage = __new_start + __len;
  }
}

template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert(iterator __position, size_type __n,
                                         const _Tp& __x)
{
  if (__n != 0) {
    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
      _Tp __x_copy = __x;
      const size_type __elems_after = end() - __position;
      iterator __old_finish(_M_finish);
      if (__elems_after > __n) {
        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
        _M_finish += __n;
        copy_backward(__position, __old_finish - __n, __old_finish);
        fill(__position, __position + __n, __x_copy);
      }
      else {
        uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
        _M_finish += __n - __elems_after;
        uninitialized_copy(__position, __old_finish, _M_finish);
        _M_finish += __elems_after;
        fill(__position, __old_finish, __x_copy);
      }
    }
    else {
      const size_type __old_size = size();
      const size_type __len = __old_size + max(__old_size, __n);
      iterator __new_start(_M_allocate(__len));
      iterator __new_finish(__new_start);
      try {
        __new_finish = uninitialized_copy(begin(), __position, __new_start);
        __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
        __new_finish
          = uninitialized_copy(__position, end(), __new_finish);
      }
      catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start.base(),__len)); throw; };

      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __new_start.base();
      _M_finish = __new_finish.base();
      _M_end_of_storage = __new_start.base() + __len;
    }
  }
}

template <class _Tp, class _Alloc> template <class _InputIterator>
void
vector<_Tp, _Alloc>::_M_range_insert(iterator __pos,
                                     _InputIterator __first,
                                     _InputIterator __last,
                                     input_iterator_tag)
{
  for ( ; __first != __last; ++__first) {
    __pos = insert(__pos, *__first);
    ++__pos;
  }
}

template <class _Tp, class _Alloc> template <class _ForwardIterator>
void
vector<_Tp, _Alloc>::_M_range_insert(iterator __position,
                                     _ForwardIterator __first,
                                     _ForwardIterator __last,
                                     forward_iterator_tag)
{
  if (__first != __last) {
    size_type __n = 0;
    distance(__first, __last, __n);
    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
      const size_type __elems_after = end() - __position;
      iterator __old_finish(_M_finish);
      if (__elems_after > __n) {
        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
        _M_finish += __n;
        copy_backward(__position, __old_finish - __n, __old_finish);
        copy(__first, __last, __position);
      }
      else {
        _ForwardIterator __mid = __first;
        advance(__mid, __elems_after);
        uninitialized_copy(__mid, __last, _M_finish);
        _M_finish += __n - __elems_after;
        uninitialized_copy(__position, __old_finish, _M_finish);
        _M_finish += __elems_after;
        copy(__first, __mid, __position);
      }
    }
    else {
      const size_type __old_size = size();
      const size_type __len = __old_size + max(__old_size, __n);
      iterator __new_start(_M_allocate(__len));
      iterator __new_finish(__new_start);
      try {
        __new_finish = uninitialized_copy(iterator(_M_start),
                                          __position, __new_start);
        __new_finish = uninitialized_copy(__first, __last, __new_finish);
        __new_finish
          = uninitialized_copy(__position, iterator(_M_finish), __new_finish);
      }
      catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start.base(),__len)); throw; };

      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __new_start.base();
      _M_finish = __new_finish.base();
      _M_end_of_storage = __new_start.base() + __len;
    }
  }
}

}
# 67 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_bvector.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_bvector.h" 3
namespace std
{

static const int __WORD_BIT = int(8*sizeof(unsigned int));

struct _Bit_reference {
  unsigned int* _M_p;
  unsigned int _M_mask;
  _Bit_reference(unsigned int* __x, unsigned int __y)
    : _M_p(__x), _M_mask(__y) {}

public:
  _Bit_reference() : _M_p(0), _M_mask(0) {}
  operator bool() const { return !(!(*_M_p & _M_mask)); }
  _Bit_reference& operator=(bool __x)
  {
    if (__x) *_M_p |= _M_mask;
    else *_M_p &= ~_M_mask;
    return *this;
  }
  _Bit_reference& operator=(const _Bit_reference& __x)
    { return *this = bool(__x); }
  bool operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }
  bool operator<(const _Bit_reference& __x) const {
    return !bool(*this) && bool(__x);
  }
  void flip() { *_M_p ^= _M_mask; }
};

inline void swap(_Bit_reference __x, _Bit_reference __y)
{
  bool __tmp = __x;
  __x = __y;
  __y = __tmp;
}

struct _Bit_iterator_base : public random_access_iterator<bool, ptrdiff_t>
{
  unsigned int* _M_p;
  unsigned int _M_offset;

  _Bit_iterator_base(unsigned int* __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) {}

  void _M_bump_up() {
    if (_M_offset++ == __WORD_BIT - 1) {
      _M_offset = 0;
      ++_M_p;
    }
  }
  void _M_bump_down() {
    if (_M_offset-- == 0) {
      _M_offset = __WORD_BIT - 1;
      --_M_p;
    }
  }

  void _M_incr(ptrdiff_t __i) {
    difference_type __n = __i + _M_offset;
    _M_p += __n / __WORD_BIT;
    __n = __n % __WORD_BIT;
    if (__n < 0) {
      _M_offset = (unsigned int) __n + __WORD_BIT;
      --_M_p;
    } else
      _M_offset = (unsigned int) __n;
  }

  bool operator==(const _Bit_iterator_base& __i) const {
    return _M_p == __i._M_p && _M_offset == __i._M_offset;
  }
  bool operator<(const _Bit_iterator_base& __i) const {
    return _M_p < __i._M_p || (_M_p == __i._M_p && _M_offset < __i._M_offset);
  }
  bool operator!=(const _Bit_iterator_base& __i) const {
    return !(*this == __i);
  }
  bool operator>(const _Bit_iterator_base& __i) const {
    return __i < *this;
  }
  bool operator<=(const _Bit_iterator_base& __i) const {
    return !(__i < *this);
  }
  bool operator>=(const _Bit_iterator_base& __i) const {
    return !(*this < __i);
  }
};

inline ptrdiff_t
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
  return __WORD_BIT * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset;
}


struct _Bit_iterator : public _Bit_iterator_base
{
  typedef _Bit_reference reference;
  typedef _Bit_reference* pointer;
  typedef _Bit_iterator iterator;

  _Bit_iterator() : _Bit_iterator_base(0, 0) {}
  _Bit_iterator(unsigned int* __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) {}

  reference operator*() const { return reference(_M_p, 1U << _M_offset); }
  iterator& operator++() {
    _M_bump_up();
    return *this;
  }
  iterator operator++(int) {
    iterator __tmp = *this;
    _M_bump_up();
    return __tmp;
  }
  iterator& operator--() {
    _M_bump_down();
    return *this;
  }
  iterator operator--(int) {
    iterator __tmp = *this;
    _M_bump_down();
    return __tmp;
  }
  iterator& operator+=(difference_type __i) {
    _M_incr(__i);
    return *this;
  }
  iterator& operator-=(difference_type __i) {
    *this += -__i;
    return *this;
  }
  iterator operator+(difference_type __i) const {
    iterator __tmp = *this;
    return __tmp += __i;
  }
  iterator operator-(difference_type __i) const {
    iterator __tmp = *this;
    return __tmp -= __i;
  }

  reference operator[](difference_type __i) { return *(*this + __i); }
};

inline _Bit_iterator
operator+(ptrdiff_t __n, const _Bit_iterator& __x) { return __x + __n; }


struct _Bit_const_iterator : public _Bit_iterator_base
{
  typedef bool reference;
  typedef bool const_reference;
  typedef const bool* pointer;
  typedef _Bit_const_iterator const_iterator;

  _Bit_const_iterator() : _Bit_iterator_base(0, 0) {}
  _Bit_const_iterator(unsigned int* __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) {}
  _Bit_const_iterator(const _Bit_iterator& __x)
    : _Bit_iterator_base(__x._M_p, __x._M_offset) {}

  const_reference operator*() const {
    return _Bit_reference(_M_p, 1U << _M_offset);
  }
  const_iterator& operator++() {
    _M_bump_up();
    return *this;
  }
  const_iterator operator++(int) {
    const_iterator __tmp = *this;
    _M_bump_up();
    return __tmp;
  }
  const_iterator& operator--() {
    _M_bump_down();
    return *this;
  }
  const_iterator operator--(int) {
    const_iterator __tmp = *this;
    _M_bump_down();
    return __tmp;
  }
  const_iterator& operator+=(difference_type __i) {
    _M_incr(__i);
    return *this;
  }
  const_iterator& operator-=(difference_type __i) {
    *this += -__i;
    return *this;
  }
  const_iterator operator+(difference_type __i) const {
    const_iterator __tmp = *this;
    return __tmp += __i;
  }
  const_iterator operator-(difference_type __i) const {
    const_iterator __tmp = *this;
    return __tmp -= __i;
  }
  const_reference operator[](difference_type __i) {
    return *(*this + __i);
  }
};

inline _Bit_const_iterator
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x) { return __x + __n; }






template <class _Allocator, bool __is_static>
class _Bvector_alloc_base {
public:
  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return _M_data_allocator; }

  _Bvector_alloc_base(const allocator_type& __a)
    : _M_data_allocator(__a), _M_start(), _M_finish(), _M_end_of_storage(0) {}

protected:
  unsigned int* _M_bit_alloc(size_t __n)
    { return _M_data_allocator.allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
  void _M_deallocate() {
    if (_M_start._M_p)
      _M_data_allocator.deallocate(_M_start._M_p,
                                   _M_end_of_storage - _M_start._M_p);
  }

  typename _Alloc_traits<unsigned int, _Allocator>::allocator_type
          _M_data_allocator;
  _Bit_iterator _M_start;
  _Bit_iterator _M_finish;
  unsigned int* _M_end_of_storage;
};


template <class _Allocator>
class _Bvector_alloc_base<_Allocator, true> {
public:
  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _Bvector_alloc_base(const allocator_type&)
    : _M_start(), _M_finish(), _M_end_of_storage(0) {}

protected:
  typedef typename _Alloc_traits<unsigned int, _Allocator>::_Alloc_type
          _Alloc_type;

  unsigned int* _M_bit_alloc(size_t __n)
    { return _Alloc_type::allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
  void _M_deallocate() {
    if (_M_start._M_p)
      _Alloc_type::deallocate(_M_start._M_p,
                              _M_end_of_storage - _M_start._M_p);
  }

  _Bit_iterator _M_start;
  _Bit_iterator _M_finish;
  unsigned int* _M_end_of_storage;
};

template <class _Alloc>
class _Bvector_base
  : public _Bvector_alloc_base<_Alloc,
                               _Alloc_traits<bool, _Alloc>::_S_instanceless>
{
  typedef _Bvector_alloc_base<_Alloc,
                              _Alloc_traits<bool, _Alloc>::_S_instanceless>
          _Base;
public:
  typedef typename _Base::allocator_type allocator_type;

  _Bvector_base(const allocator_type& __a) : _Base(__a) {}
  ~_Bvector_base() { _Base::_M_deallocate(); }
};

}


# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_vector.h" 1 3
# 347 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_bvector.h" 2 3
namespace std
{

template <typename _Alloc>
  class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
  {
  public:
    typedef bool value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef _Bit_reference reference;
    typedef bool const_reference;
    typedef _Bit_reference* pointer;
    typedef const bool* const_pointer;

    typedef _Bit_iterator iterator;
    typedef _Bit_const_iterator const_iterator;

    typedef reverse_iterator<const_iterator> const_reverse_iterator;
    typedef reverse_iterator<iterator> reverse_iterator;

    typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type;
    allocator_type get_allocator() const {
      return _Bvector_base<_Alloc>::get_allocator();
    }

  protected:
    using _Bvector_base<_Alloc>::_M_bit_alloc;
    using _Bvector_base<_Alloc>::_M_deallocate;
    using _Bvector_base<_Alloc>::_M_start;
    using _Bvector_base<_Alloc>::_M_finish;
    using _Bvector_base<_Alloc>::_M_end_of_storage;

  protected:
    void _M_initialize(size_type __n) {
      unsigned int* __q = _M_bit_alloc(__n);
      _M_end_of_storage = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
      _M_start = iterator(__q, 0);
      _M_finish = _M_start + difference_type(__n);
    }
    void _M_insert_aux(iterator __position, bool __x) {
      if (_M_finish._M_p != _M_end_of_storage) {
        copy_backward(__position, _M_finish, _M_finish + 1);
        *__position = __x;
        ++_M_finish;
      }
      else {
        size_type __len = size() ? 2 * size() : __WORD_BIT;
        unsigned int* __q = _M_bit_alloc(__len);
        iterator __i = copy(begin(), __position, iterator(__q, 0));
        *__i++ = __x;
        _M_finish = copy(__position, end(), __i);
        _M_deallocate();
        _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
        _M_start = iterator(__q, 0);
      }
    }

    template <class _InputIterator>
    void _M_initialize_range(_InputIterator __first, _InputIterator __last,
                             input_iterator_tag) {
      _M_start = iterator();
      _M_finish = iterator();
      _M_end_of_storage = 0;
      for ( ; __first != __last; ++__first)
        push_back(*__first);
    }

    template <class _ForwardIterator>
    void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
                             forward_iterator_tag) {
      size_type __n = 0;
      distance(__first, __last, __n);
      _M_initialize(__n);
      copy(__first, __last, _M_start);
    }

    template <class _InputIterator>
    void _M_insert_range(iterator __pos,
                         _InputIterator __first, _InputIterator __last,
                         input_iterator_tag) {
      for ( ; __first != __last; ++__first) {
        __pos = insert(__pos, *__first);
        ++__pos;
      }
    }

    template <class _ForwardIterator>
    void _M_insert_range(iterator __position,
                         _ForwardIterator __first, _ForwardIterator __last,
                         forward_iterator_tag) {
      if (__first != __last) {
        size_type __n = 0;
        distance(__first, __last, __n);
        if (capacity() - size() >= __n) {
          copy_backward(__position, end(), _M_finish + difference_type(__n));
          copy(__first, __last, __position);
          _M_finish += difference_type(__n);
        }
        else {
          size_type __len = size() + max(size(), __n);
          unsigned int* __q = _M_bit_alloc(__len);
          iterator __i = copy(begin(), __position, iterator(__q, 0));
          __i = copy(__first, __last, __i);
          _M_finish = copy(__position, end(), __i);
          _M_deallocate();
          _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
          _M_start = iterator(__q, 0);
        }
      }
    }

  public:
    iterator begin() { return _M_start; }
    const_iterator begin() const { return _M_start; }
    iterator end() { return _M_finish; }
    const_iterator end() const { return _M_finish; }

    reverse_iterator rbegin() { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const {
      return const_reverse_iterator(end());
    }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const {
      return const_reverse_iterator(begin());
    }

    size_type size() const { return size_type(end() - begin()); }
    size_type max_size() const { return size_type(-1); }
    size_type capacity() const {
      return size_type(const_iterator(_M_end_of_storage, 0) - begin());
    }
    bool empty() const { return begin() == end(); }

    reference operator[](size_type __n)
      { return *(begin() + difference_type(__n)); }
    const_reference operator[](size_type __n) const
      { return *(begin() + difference_type(__n)); }

    void _M_range_check(size_type __n) const {
      if (__n >= this->size())
        __throw_range_error("vector<bool>");
    }

    reference at(size_type __n)
      { _M_range_check(__n); return (*this)[__n]; }
    const_reference at(size_type __n) const
      { _M_range_check(__n); return (*this)[__n]; }

    explicit vector(const allocator_type& __a = allocator_type())
      : _Bvector_base<_Alloc>(__a) {}

    vector(size_type __n, bool __value,
              const allocator_type& __a = allocator_type())
      : _Bvector_base<_Alloc>(__a)
    {
      _M_initialize(__n);
      fill(_M_start._M_p, _M_end_of_storage, __value ? ~0 : 0);
    }

    explicit vector(size_type __n)
      : _Bvector_base<_Alloc>(allocator_type())
    {
      _M_initialize(__n);
      fill(_M_start._M_p, _M_end_of_storage, 0);
    }

    vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator()) {
      _M_initialize(__x.size());
      copy(__x.begin(), __x.end(), _M_start);
    }



    template <class _Integer>
    void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
      _M_initialize(__n);
      fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
    }

    template <class _InputIterator>
    void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
                                __false_type) {
      _M_initialize_range(__first, __last, __iterator_category(__first));
    }

    template <class _InputIterator>
    vector(_InputIterator __first, _InputIterator __last,
             const allocator_type& __a = allocator_type())
      : _Bvector_base<_Alloc>(__a)
    {
      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
      _M_initialize_dispatch(__first, __last, _Integral());
    }

    ~vector() { }

    vector& operator=(const vector& __x) {
      if (&__x == this) return *this;
      if (__x.size() > capacity()) {
        _M_deallocate();
        _M_initialize(__x.size());
      }
      copy(__x.begin(), __x.end(), begin());
      _M_finish = begin() + difference_type(__x.size());
      return *this;
    }






    void _M_fill_assign(size_t __n, bool __x) {
      if (__n > size()) {
        fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
        insert(end(), __n - size(), __x);
      }
      else {
        erase(begin() + __n, end());
        fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
      }
    }

    void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }

    template <class _InputIterator>
    void assign(_InputIterator __first, _InputIterator __last) {
      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
      _M_assign_dispatch(__first, __last, _Integral());
    }

    template <class _Integer>
    void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
      { _M_fill_assign((size_t) __n, (bool) __val); }

    template <class _InputIter>
    void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
      { _M_assign_aux(__first, __last, __iterator_category(__first)); }

    template <class _InputIterator>
    void _M_assign_aux(_InputIterator __first, _InputIterator __last,
                       input_iterator_tag) {
      iterator __cur = begin();
      for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
        *__cur = *__first;
      if (__first == __last)
        erase(__cur, end());
      else
        insert(end(), __first, __last);
    }

    template <class _ForwardIterator>
    void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                       forward_iterator_tag) {
      size_type __len = 0;
      distance(__first, __last, __len);
      if (__len < size())
        erase(copy(__first, __last, begin()), end());
      else {
        _ForwardIterator __mid = __first;
        advance(__mid, size());
        copy(__first, __mid, begin());
        insert(end(), __mid, __last);
      }
    }

    void reserve(size_type __n) {
      if (capacity() < __n) {
        unsigned int* __q = _M_bit_alloc(__n);
        _M_finish = copy(begin(), end(), iterator(__q, 0));
        _M_deallocate();
        _M_start = iterator(__q, 0);
        _M_end_of_storage = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
      }
    }

    reference front() { return *begin(); }
    const_reference front() const { return *begin(); }
    reference back() { return *(end() - 1); }
    const_reference back() const { return *(end() - 1); }
    void push_back(bool __x) {
      if (_M_finish._M_p != _M_end_of_storage)
        *_M_finish++ = __x;
      else
        _M_insert_aux(end(), __x);
    }
    void swap(vector<bool, _Alloc>& __x) {
      std::swap(_M_start, __x._M_start);
      std::swap(_M_finish, __x._M_finish);
      std::swap(_M_end_of_storage, __x._M_end_of_storage);
    }
    iterator insert(iterator __position, bool __x = bool()) {
      difference_type __n = __position - begin();
      if (_M_finish._M_p != _M_end_of_storage && __position == end())
        *_M_finish++ = __x;
      else
        _M_insert_aux(__position, __x);
      return begin() + __n;
    }



    template <class _Integer>
    void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
                            __true_type) {
      _M_fill_insert(__pos, __n, __x);
    }

    template <class _InputIterator>
    void _M_insert_dispatch(iterator __pos,
                            _InputIterator __first, _InputIterator __last,
                            __false_type) {
      _M_insert_range(__pos, __first, __last, __iterator_category(__first));
    }

    template <class _InputIterator>
    void insert(iterator __position,
                _InputIterator __first, _InputIterator __last) {
      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
      _M_insert_dispatch(__position, __first, __last, _Integral());
    }

    void _M_fill_insert(iterator __position, size_type __n, bool __x) {
      if (__n == 0) return;
      if (capacity() - size() >= __n) {
        copy_backward(__position, end(), _M_finish + difference_type(__n));
        fill(__position, __position + difference_type(__n), __x);
        _M_finish += difference_type(__n);
      }
      else {
        size_type __len = size() + max(size(), __n);
        unsigned int* __q = _M_bit_alloc(__len);
        iterator __i = copy(begin(), __position, iterator(__q, 0));
        fill_n(__i, __n, __x);
        _M_finish = copy(__position, end(), __i + difference_type(__n));
        _M_deallocate();
        _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
        _M_start = iterator(__q, 0);
      }
    }

    void insert(iterator __position, size_type __n, bool __x) {
      _M_fill_insert(__position, __n, __x);
    }

    void pop_back() { --_M_finish; }
    iterator erase(iterator __position) {
      if (__position + 1 != end())
        copy(__position + 1, end(), __position);
        --_M_finish;
      return __position;
    }
    iterator erase(iterator __first, iterator __last) {
      _M_finish = copy(__last, end(), __first);
      return __first;
    }
    void resize(size_type __new_size, bool __x = bool()) {
      if (__new_size < size())
        erase(begin() + difference_type(__new_size), end());
      else
        insert(end(), __new_size - size(), __x);
    }
    void flip() {
      for (unsigned int* __p = _M_start._M_p; __p != _M_end_of_storage; ++__p)
        *__p = ~*__p;
    }

    void clear() { erase(begin(), end()); }
  };


typedef vector<bool, alloc> bit_vector;

}
# 68 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 2 3
# 32 "/usr/local/gcc-3.0.1/include/g++-v3/vector" 2 3
# 2 "test.cpp" 2
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/map" 1 3
# 31 "/usr/local/gcc-3.0.1/include/g++-v3/map" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_map.h" 1 3
# 60 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_map.h" 3


# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tree.h" 1 3
# 85 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tree.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 1 3
# 86 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tree.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 1 3
# 87 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tree.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_construct.h" 1 3
# 88 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tree.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_function.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_function.h" 3
namespace std
{

template <class _Arg, class _Result>
struct unary_function {
  typedef _Arg argument_type;
  typedef _Result result_type;
};

template <class _Arg1, class _Arg2, class _Result>
struct binary_function {
  typedef _Arg1 first_argument_type;
  typedef _Arg2 second_argument_type;
  typedef _Result result_type;
};

template <class _Tp>
struct plus : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
};

template <class _Tp>
struct minus : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
};

template <class _Tp>
struct multiplies : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
};

template <class _Tp>
struct divides : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
};



template <class _Tp> inline _Tp identity_element(plus<_Tp>) {
  return _Tp(0);
}
template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {
  return _Tp(1);
}

template <class _Tp>
struct modulus : public binary_function<_Tp,_Tp,_Tp>
{
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
};

template <class _Tp>
struct negate : public unary_function<_Tp,_Tp>
{
  _Tp operator()(const _Tp& __x) const { return -__x; }
};

template <class _Tp>
struct equal_to : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
};

template <class _Tp>
struct not_equal_to : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
};

template <class _Tp>
struct greater : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
};

template <class _Tp>
struct less : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
};

template <class _Tp>
struct greater_equal : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
};

template <class _Tp>
struct less_equal : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
};

template <class _Tp>
struct logical_and : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
};

template <class _Tp>
struct logical_or : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
};

template <class _Tp>
struct logical_not : public unary_function<_Tp,bool>
{
  bool operator()(const _Tp& __x) const { return !__x; }
};

template <class _Predicate>
class unary_negate
  : public unary_function<typename _Predicate::argument_type, bool> {
protected:
  _Predicate _M_pred;
public:
  explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::argument_type& __x) const {
    return !_M_pred(__x);
  }
};

template <class _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{
  return unary_negate<_Predicate>(__pred);
}

template <class _Predicate>
class binary_negate
  : public binary_function<typename _Predicate::first_argument_type,
                           typename _Predicate::second_argument_type,
                           bool> {
protected:
  _Predicate _M_pred;
public:
  explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::first_argument_type& __x,
                  const typename _Predicate::second_argument_type& __y) const
  {
    return !_M_pred(__x, __y);
  }
};

template <class _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{
  return binary_negate<_Predicate>(__pred);
}

template <class _Operation>
class binder1st
  : public unary_function<typename _Operation::second_argument_type,
                          typename _Operation::result_type> {
protected:
  _Operation op;
  typename _Operation::first_argument_type value;
public:
  binder1st(const _Operation& __x,
            const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) {}
  typename _Operation::result_type
  operator()(const typename _Operation::second_argument_type& __x) const {
    return op(value, __x);
  }


  typename _Operation::result_type
  operator()(typename _Operation::second_argument_type& __x) const {
    return op(value, __x);
  }

};

template <class _Operation, class _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
  typedef typename _Operation::first_argument_type _Arg1_type;
  return binder1st<_Operation>(__fn, _Arg1_type(__x));
}

template <class _Operation>
class binder2nd
  : public unary_function<typename _Operation::first_argument_type,
                          typename _Operation::result_type> {
protected:
  _Operation op;
  typename _Operation::second_argument_type value;
public:
  binder2nd(const _Operation& __x,
            const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) {}
  typename _Operation::result_type
  operator()(const typename _Operation::first_argument_type& __x) const {
    return op(__x, value);
  }


  typename _Operation::result_type
  operator()(typename _Operation::first_argument_type& __x) const {
    return op(__x, value);
  }

};

template <class _Operation, class _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
  typedef typename _Operation::second_argument_type _Arg2_type;
  return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}



template <class _Operation1, class _Operation2>
class unary_compose
  : public unary_function<typename _Operation2::argument_type,
                          typename _Operation1::result_type>
{
protected:
  _Operation1 _M_fn1;
  _Operation2 _M_fn2;
public:
  unary_compose(const _Operation1& __x, const _Operation2& __y)
    : _M_fn1(__x), _M_fn2(__y) {}
  typename _Operation1::result_type
  operator()(const typename _Operation2::argument_type& __x) const {
    return _M_fn1(_M_fn2(__x));
  }
};

template <class _Operation1, class _Operation2>
inline unary_compose<_Operation1,_Operation2>
compose1(const _Operation1& __fn1, const _Operation2& __fn2)
{
  return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
}

template <class _Operation1, class _Operation2, class _Operation3>
class binary_compose
  : public unary_function<typename _Operation2::argument_type,
                          typename _Operation1::result_type> {
protected:
  _Operation1 _M_fn1;
  _Operation2 _M_fn2;
  _Operation3 _M_fn3;
public:
  binary_compose(const _Operation1& __x, const _Operation2& __y,
                 const _Operation3& __z)
    : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
  typename _Operation1::result_type
  operator()(const typename _Operation2::argument_type& __x) const {
    return _M_fn1(_M_fn2(__x), _M_fn3(__x));
  }
};

template <class _Operation1, class _Operation2, class _Operation3>
inline binary_compose<_Operation1, _Operation2, _Operation3>
compose2(const _Operation1& __fn1, const _Operation2& __fn2,
         const _Operation3& __fn3)
{
  return binary_compose<_Operation1,_Operation2,_Operation3>
    (__fn1, __fn2, __fn3);
}

template <class _Arg, class _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
protected:
  _Result (*_M_ptr)(_Arg);
public:
  pointer_to_unary_function() {}
  explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
  _Result operator()(_Arg __x) const { return _M_ptr(__x); }
};

template <class _Arg, class _Result>
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
{
  return pointer_to_unary_function<_Arg, _Result>(__x);
}

template <class _Arg1, class _Arg2, class _Result>
class pointer_to_binary_function :
  public binary_function<_Arg1,_Arg2,_Result> {
protected:
    _Result (*_M_ptr)(_Arg1, _Arg2);
public:
    pointer_to_binary_function() {}
    explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) {}
    _Result operator()(_Arg1 __x, _Arg2 __y) const {
      return _M_ptr(__x, __y);
    }
};

template <class _Arg1, class _Arg2, class _Result>
inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
  return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
}


template <class _Tp>
struct _Identity : public unary_function<_Tp,_Tp> {
  _Tp& operator()(_Tp& __x) const { return __x; }
  const _Tp& operator()(const _Tp& __x) const { return __x; }
};

template <class _Tp> struct identity : public _Identity<_Tp> {};


template <class _Pair>
struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
  typename _Pair::first_type& operator()(_Pair& __x) const {
    return __x.first;
  }
  const typename _Pair::first_type& operator()(const _Pair& __x) const {
    return __x.first;
  }
};

template <class _Pair>
struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
{
  typename _Pair::second_type& operator()(_Pair& __x) const {
    return __x.second;
  }
  const typename _Pair::second_type& operator()(const _Pair& __x) const {
    return __x.second;
  }
};

template <class _Pair> struct select1st : public _Select1st<_Pair> {};
template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};


template <class _Arg1, class _Arg2>
struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
  _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
};

template <class _Arg1, class _Arg2>
struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
  _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
};

template <class _Arg1, class _Arg2>
struct project1st : public _Project1st<_Arg1, _Arg2> {};

template <class _Arg1, class _Arg2>
struct project2nd : public _Project2nd<_Arg1, _Arg2> {};





template <class _Result>
struct _Constant_void_fun {
  typedef _Result result_type;
  result_type _M_val;

  _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
  const result_type& operator()() const { return _M_val; }
};

template <class _Result, class _Argument>
struct _Constant_unary_fun {
  typedef _Argument argument_type;
  typedef _Result result_type;
  result_type _M_val;

  _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
  const result_type& operator()(const _Argument&) const { return _M_val; }
};

template <class _Result, class _Arg1, class _Arg2>
struct _Constant_binary_fun {
  typedef _Arg1 first_argument_type;
  typedef _Arg2 second_argument_type;
  typedef _Result result_type;
  _Result _M_val;

  _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
  const result_type& operator()(const _Arg1&, const _Arg2&) const {
    return _M_val;
  }
};

template <class _Result>
struct constant_void_fun : public _Constant_void_fun<_Result> {
  constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
};


template <class _Result,
          class _Argument = _Result>
struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
{
  constant_unary_fun(const _Result& __v)
    : _Constant_unary_fun<_Result, _Argument>(__v) {}
};


template <class _Result,
          class _Arg1 = _Result,
          class _Arg2 = _Arg1>
struct constant_binary_fun
  : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
{
  constant_binary_fun(const _Result& __v)
    : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
};

template <class _Result>
inline constant_void_fun<_Result> constant0(const _Result& __val)
{
  return constant_void_fun<_Result>(__val);
}

template <class _Result>
inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
{
  return constant_unary_fun<_Result,_Result>(__val);
}

template <class _Result>
inline constant_binary_fun<_Result,_Result,_Result>
constant2(const _Result& __val)
{
  return constant_binary_fun<_Result,_Result,_Result>(__val);
}



class subtractive_rng : public unary_function<unsigned int, unsigned int> {
private:
  unsigned int _M_table[55];
  size_t _M_index1;
  size_t _M_index2;
public:
  unsigned int operator()(unsigned int __limit) {
    _M_index1 = (_M_index1 + 1) % 55;
    _M_index2 = (_M_index2 + 1) % 55;
    _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
    return _M_table[_M_index1] % __limit;
  }

  void _M_initialize(unsigned int __seed)
  {
    unsigned int __k = 1;
    _M_table[54] = __seed;
    size_t __i;
    for (__i = 0; __i < 54; __i++) {
        size_t __ii = (21 * (__i + 1) % 55) - 1;
        _M_table[__ii] = __k;
        __k = __seed - __k;
        __seed = _M_table[__ii];
    }
    for (int __loop = 0; __loop < 4; __loop++) {
        for (__i = 0; __i < 55; __i++)
            _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
    }
    _M_index1 = 0;
    _M_index2 = 31;
  }

  subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
  subtractive_rng() { _M_initialize(161803398u); }
};
# 562 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_function.h" 3
template <class _Ret, class _Tp>
class mem_fun_t : public unary_function<_Tp*,_Ret> {
public:
  explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)();
};

template <class _Ret, class _Tp>
class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
public:
  explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;
};


template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)();
};

template <class _Ret, class _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;
};

template <class _Ret, class _Tp, class _Arg>
class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
public:
  explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg);
};

template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
public:
  explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p, _Arg __x) const
    { return (__p->*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};

template <class _Ret, class _Tp, class _Arg>
class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg);
};

template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};

template <class _Tp>
class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
public:
  explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  void operator()(_Tp* __p) const { (__p->*_M_f)(); }
private:
  void (_Tp::*_M_f)();
};

template <class _Tp>
class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
public:
  explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
private:
  void (_Tp::*_M_f)() const;
};

template <class _Tp>
class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
  explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  void operator()(_Tp& __r) const { (__r.*_M_f)(); }
private:
  void (_Tp::*_M_f)();
};

template <class _Tp>
class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
  explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
private:
  void (_Tp::*_M_f)() const;
};

template <class _Tp, class _Arg>
class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
public:
  explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg);
};

template <class _Tp, class _Arg>
class const_mem_fun1_t<void, _Tp, _Arg>
  : public binary_function<const _Tp*,_Arg,void> {
public:
  explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg) const;
};

template <class _Tp, class _Arg>
class mem_fun1_ref_t<void, _Tp, _Arg>
  : public binary_function<_Tp,_Arg,void> {
public:
  explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg);
};

template <class _Tp, class _Arg>
class const_mem_fun1_ref_t<void, _Tp, _Arg>
  : public binary_function<_Tp,_Arg,void> {
public:
  explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg) const;
};







template <class _Ret, class _Tp>
inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
  { return mem_fun_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp>
inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
  { return const_mem_fun_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp>
inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)())
  { return mem_fun_ref_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp>
inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
  { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

}
# 89 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tree.h" 2 3

namespace std
{

typedef bool _Rb_tree_Color_type;
const _Rb_tree_Color_type _S_rb_tree_red = false;
const _Rb_tree_Color_type _S_rb_tree_black = true;

struct _Rb_tree_node_base
{
  typedef _Rb_tree_Color_type _Color_type;
  typedef _Rb_tree_node_base* _Base_ptr;

  _Color_type _M_color;
  _Base_ptr _M_parent;
  _Base_ptr _M_left;
  _Base_ptr _M_right;

  static _Base_ptr _S_minimum(_Base_ptr __x)
  {
    while (__x->_M_left != 0) __x = __x->_M_left;
    return __x;
  }

  static _Base_ptr _S_maximum(_Base_ptr __x)
  {
    while (__x->_M_right != 0) __x = __x->_M_right;
    return __x;
  }
};

template <class _Value>
struct _Rb_tree_node : public _Rb_tree_node_base
{
  typedef _Rb_tree_node<_Value>* _Link_type;
  _Value _M_value_field;
};


struct _Rb_tree_base_iterator
{
  typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
  typedef bidirectional_iterator_tag iterator_category;
  typedef ptrdiff_t difference_type;
  _Base_ptr _M_node;

  void _M_increment()
  {
    if (_M_node->_M_right != 0) {
      _M_node = _M_node->_M_right;
      while (_M_node->_M_left != 0)
        _M_node = _M_node->_M_left;
    }
    else {
      _Base_ptr __y = _M_node->_M_parent;
      while (_M_node == __y->_M_right) {
        _M_node = __y;
        __y = __y->_M_parent;
      }
      if (_M_node->_M_right != __y)
        _M_node = __y;
    }
  }

  void _M_decrement()
  {
    if (_M_node->_M_color == _S_rb_tree_red &&
        _M_node->_M_parent->_M_parent == _M_node)
      _M_node = _M_node->_M_right;
    else if (_M_node->_M_left != 0) {
      _Base_ptr __y = _M_node->_M_left;
      while (__y->_M_right != 0)
        __y = __y->_M_right;
      _M_node = __y;
    }
    else {
      _Base_ptr __y = _M_node->_M_parent;
      while (_M_node == __y->_M_left) {
        _M_node = __y;
        __y = __y->_M_parent;
      }
      _M_node = __y;
    }
  }
};

template <class _Value, class _Ref, class _Ptr>
struct _Rb_tree_iterator : public _Rb_tree_base_iterator
{
  typedef _Value value_type;
  typedef _Ref reference;
  typedef _Ptr pointer;
  typedef _Rb_tree_iterator<_Value, _Value&, _Value*>
    iterator;
  typedef _Rb_tree_iterator<_Value, const _Value&, const _Value*>
    const_iterator;
  typedef _Rb_tree_iterator<_Value, _Ref, _Ptr>
    _Self;
  typedef _Rb_tree_node<_Value>* _Link_type;

  _Rb_tree_iterator() {}
  _Rb_tree_iterator(_Link_type __x) { _M_node = __x; }
  _Rb_tree_iterator(const iterator& __it) { _M_node = __it._M_node; }

  reference operator*() const { return _Link_type(_M_node)->_M_value_field; }
  pointer operator->() const { return &(operator*()); }

  _Self& operator++() { _M_increment(); return *this; }
  _Self operator++(int) {
    _Self __tmp = *this;
    _M_increment();
    return __tmp;
  }

  _Self& operator--() { _M_decrement(); return *this; }
  _Self operator--(int) {
    _Self __tmp = *this;
    _M_decrement();
    return __tmp;
  }
};

template <class _Value, class _Ref, class _Ptr>
inline bool operator==(const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __x,
                       const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __y) {
  return __x._M_node == __y._M_node;
}

template <class _Value>
inline bool operator==(const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __x,
                       const _Rb_tree_iterator<_Value, _Value&, _Value*>& __y) {
  return __x._M_node == __y._M_node;
}

template <class _Value>
inline bool operator==(const _Rb_tree_iterator<_Value, _Value&, _Value*>& __x,
                       const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __y) {
  return __x._M_node == __y._M_node;
}

template <class _Value, class _Ref, class _Ptr>
inline bool operator!=(const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __x,
                       const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __y) {
  return __x._M_node != __y._M_node;
}

template <class _Value>
inline bool operator!=(const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __x,
                       const _Rb_tree_iterator<_Value, _Value&, _Value*>& __y) {
  return __x._M_node != __y._M_node;
}

template <class _Value>
inline bool operator!=(const _Rb_tree_iterator<_Value, _Value&, _Value*>& __x,
                       const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __y) {
  return __x._M_node != __y._M_node;
}

inline void
_Rb_tree_rotate_left(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
  _Rb_tree_node_base* __y = __x->_M_right;
  __x->_M_right = __y->_M_left;
  if (__y->_M_left !=0)
    __y->_M_left->_M_parent = __x;
  __y->_M_parent = __x->_M_parent;

  if (__x == __root)
    __root = __y;
  else if (__x == __x->_M_parent->_M_left)
    __x->_M_parent->_M_left = __y;
  else
    __x->_M_parent->_M_right = __y;
  __y->_M_left = __x;
  __x->_M_parent = __y;
}

inline void
_Rb_tree_rotate_right(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
  _Rb_tree_node_base* __y = __x->_M_left;
  __x->_M_left = __y->_M_right;
  if (__y->_M_right != 0)
    __y->_M_right->_M_parent = __x;
  __y->_M_parent = __x->_M_parent;

  if (__x == __root)
    __root = __y;
  else if (__x == __x->_M_parent->_M_right)
    __x->_M_parent->_M_right = __y;
  else
    __x->_M_parent->_M_left = __y;
  __y->_M_right = __x;
  __x->_M_parent = __y;
}

inline void
_Rb_tree_rebalance(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
  __x->_M_color = _S_rb_tree_red;
  while (__x != __root && __x->_M_parent->_M_color == _S_rb_tree_red) {
    if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left) {
      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right;
      if (__y && __y->_M_color == _S_rb_tree_red) {
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __y->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        __x = __x->_M_parent->_M_parent;
      }
      else {
        if (__x == __x->_M_parent->_M_right) {
          __x = __x->_M_parent;
          _Rb_tree_rotate_left(__x, __root);
        }
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        _Rb_tree_rotate_right(__x->_M_parent->_M_parent, __root);
      }
    }
    else {
      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;
      if (__y && __y->_M_color == _S_rb_tree_red) {
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __y->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        __x = __x->_M_parent->_M_parent;
      }
      else {
        if (__x == __x->_M_parent->_M_left) {
          __x = __x->_M_parent;
          _Rb_tree_rotate_right(__x, __root);
        }
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        _Rb_tree_rotate_left(__x->_M_parent->_M_parent, __root);
      }
    }
  }
  __root->_M_color = _S_rb_tree_black;
}

inline _Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* __z,
                             _Rb_tree_node_base*& __root,
                             _Rb_tree_node_base*& __leftmost,
                             _Rb_tree_node_base*& __rightmost)
{
  _Rb_tree_node_base* __y = __z;
  _Rb_tree_node_base* __x = 0;
  _Rb_tree_node_base* __x_parent = 0;
  if (__y->_M_left == 0)
    __x = __y->_M_right;
  else
    if (__y->_M_right == 0)
      __x = __y->_M_left;
    else {
      __y = __y->_M_right;
      while (__y->_M_left != 0)
        __y = __y->_M_left;
      __x = __y->_M_right;
    }
  if (__y != __z) {
    __z->_M_left->_M_parent = __y;
    __y->_M_left = __z->_M_left;
    if (__y != __z->_M_right) {
      __x_parent = __y->_M_parent;
      if (__x) __x->_M_parent = __y->_M_parent;
      __y->_M_parent->_M_left = __x;
      __y->_M_right = __z->_M_right;
      __z->_M_right->_M_parent = __y;
    }
    else
      __x_parent = __y;
    if (__root == __z)
      __root = __y;
    else if (__z->_M_parent->_M_left == __z)
      __z->_M_parent->_M_left = __y;
    else
      __z->_M_parent->_M_right = __y;
    __y->_M_parent = __z->_M_parent;
    std::swap(__y->_M_color, __z->_M_color);
    __y = __z;

  }
  else {
    __x_parent = __y->_M_parent;
    if (__x) __x->_M_parent = __y->_M_parent;
    if (__root == __z)
      __root = __x;
    else
      if (__z->_M_parent->_M_left == __z)
        __z->_M_parent->_M_left = __x;
      else
        __z->_M_parent->_M_right = __x;
    if (__leftmost == __z)
      if (__z->_M_right == 0)
        __leftmost = __z->_M_parent;

      else
        __leftmost = _Rb_tree_node_base::_S_minimum(__x);
    if (__rightmost == __z)
      if (__z->_M_left == 0)
        __rightmost = __z->_M_parent;

      else
        __rightmost = _Rb_tree_node_base::_S_maximum(__x);
  }
  if (__y->_M_color != _S_rb_tree_red) {
    while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black))
      if (__x == __x_parent->_M_left) {
        _Rb_tree_node_base* __w = __x_parent->_M_right;
        if (__w->_M_color == _S_rb_tree_red) {
          __w->_M_color = _S_rb_tree_black;
          __x_parent->_M_color = _S_rb_tree_red;
          _Rb_tree_rotate_left(__x_parent, __root);
          __w = __x_parent->_M_right;
        }
        if ((__w->_M_left == 0 ||
             __w->_M_left->_M_color == _S_rb_tree_black) &&
            (__w->_M_right == 0 ||
             __w->_M_right->_M_color == _S_rb_tree_black)) {
          __w->_M_color = _S_rb_tree_red;
          __x = __x_parent;
          __x_parent = __x_parent->_M_parent;
        } else {
          if (__w->_M_right == 0 ||
              __w->_M_right->_M_color == _S_rb_tree_black) {
            if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
            __w->_M_color = _S_rb_tree_red;
            _Rb_tree_rotate_right(__w, __root);
            __w = __x_parent->_M_right;
          }
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_left(__x_parent, __root);
          break;
        }
      } else {
        _Rb_tree_node_base* __w = __x_parent->_M_left;
        if (__w->_M_color == _S_rb_tree_red) {
          __w->_M_color = _S_rb_tree_black;
          __x_parent->_M_color = _S_rb_tree_red;
          _Rb_tree_rotate_right(__x_parent, __root);
          __w = __x_parent->_M_left;
        }
        if ((__w->_M_right == 0 ||
             __w->_M_right->_M_color == _S_rb_tree_black) &&
            (__w->_M_left == 0 ||
             __w->_M_left->_M_color == _S_rb_tree_black)) {
          __w->_M_color = _S_rb_tree_red;
          __x = __x_parent;
          __x_parent = __x_parent->_M_parent;
        } else {
          if (__w->_M_left == 0 ||
              __w->_M_left->_M_color == _S_rb_tree_black) {
            if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
            __w->_M_color = _S_rb_tree_red;
            _Rb_tree_rotate_left(__w, __root);
            __w = __x_parent->_M_left;
          }
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_right(__x_parent, __root);
          break;
        }
      }
    if (__x) __x->_M_color = _S_rb_tree_black;
  }
  return __y;
}







template <class _Tp, class _Alloc, bool _S_instanceless>
class _Rb_tree_alloc_base {
public:
  typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
  allocator_type get_allocator() const { return _M_node_allocator; }

  _Rb_tree_alloc_base(const allocator_type& __a)
    : _M_node_allocator(__a), _M_header(0) {}

protected:
  typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::allocator_type
           _M_node_allocator;
  _Rb_tree_node<_Tp>* _M_header;

  _Rb_tree_node<_Tp>* _M_get_node()
    { return _M_node_allocator.allocate(1); }
  void _M_put_node(_Rb_tree_node<_Tp>* __p)
    { _M_node_allocator.deallocate(__p, 1); }
};


template <class _Tp, class _Alloc>
class _Rb_tree_alloc_base<_Tp, _Alloc, true> {
public:
  typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _Rb_tree_alloc_base(const allocator_type&) : _M_header(0) {}

protected:
  _Rb_tree_node<_Tp>* _M_header;

  typedef typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::_Alloc_type
          _Alloc_type;

  _Rb_tree_node<_Tp>* _M_get_node()
    { return _Alloc_type::allocate(1); }
  void _M_put_node(_Rb_tree_node<_Tp>* __p)
    { _Alloc_type::deallocate(__p, 1); }
};

template <class _Tp, class _Alloc>
struct _Rb_tree_base
  : public _Rb_tree_alloc_base<_Tp, _Alloc,
                               _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
{
  typedef _Rb_tree_alloc_base<_Tp, _Alloc,
                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
          _Base;
  typedef typename _Base::allocator_type allocator_type;

  _Rb_tree_base(const allocator_type& __a)
    : _Base(__a) { _M_header = _M_get_node(); }
  ~_Rb_tree_base() { _M_put_node(_M_header); }

};


template <class _Key, class _Value, class _KeyOfValue, class _Compare,
          class _Alloc = allocator<_Value> >
class _Rb_tree : protected _Rb_tree_base<_Value, _Alloc> {
  typedef _Rb_tree_base<_Value, _Alloc> _Base;
protected:
  typedef _Rb_tree_node_base* _Base_ptr;
  typedef _Rb_tree_node<_Value> _Rb_tree_node;
  typedef _Rb_tree_Color_type _Color_type;
public:
  typedef _Key key_type;
  typedef _Value value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef _Rb_tree_node* _Link_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }

protected:
  using _Base::_M_get_node;
  using _Base::_M_put_node;
  using _Base::_M_header;

protected:

  _Link_type _M_create_node(const value_type& __x)
  {
    _Link_type __tmp = _M_get_node();
    try {
      construct(&__tmp->_M_value_field, __x);
    }
    catch(...) { _M_put_node(__tmp); throw; };
    return __tmp;
  }

  _Link_type _M_clone_node(_Link_type __x)
  {
    _Link_type __tmp = _M_create_node(__x->_M_value_field);
    __tmp->_M_color = __x->_M_color;
    __tmp->_M_left = 0;
    __tmp->_M_right = 0;
    return __tmp;
  }

  void destroy_node(_Link_type __p)
  {
    destroy(&__p->_M_value_field);
    _M_put_node(__p);
  }

protected:
  size_type _M_node_count;
  _Compare _M_key_compare;

  _Link_type& _M_root() const
    { return (_Link_type&) _M_header->_M_parent; }
  _Link_type& _M_leftmost() const
    { return (_Link_type&) _M_header->_M_left; }
  _Link_type& _M_rightmost() const
    { return (_Link_type&) _M_header->_M_right; }

  static _Link_type& _S_left(_Link_type __x)
    { return (_Link_type&)(__x->_M_left); }
  static _Link_type& _S_right(_Link_type __x)
    { return (_Link_type&)(__x->_M_right); }
  static _Link_type& _S_parent(_Link_type __x)
    { return (_Link_type&)(__x->_M_parent); }
  static reference _S_value(_Link_type __x)
    { return __x->_M_value_field; }
  static const _Key& _S_key(_Link_type __x)
    { return _KeyOfValue()(_S_value(__x)); }
  static _Color_type& _S_color(_Link_type __x)
    { return (_Color_type&)(__x->_M_color); }

  static _Link_type& _S_left(_Base_ptr __x)
    { return (_Link_type&)(__x->_M_left); }
  static _Link_type& _S_right(_Base_ptr __x)
    { return (_Link_type&)(__x->_M_right); }
  static _Link_type& _S_parent(_Base_ptr __x)
    { return (_Link_type&)(__x->_M_parent); }
  static reference _S_value(_Base_ptr __x)
    { return ((_Link_type)__x)->_M_value_field; }
  static const _Key& _S_key(_Base_ptr __x)
    { return _KeyOfValue()(_S_value(_Link_type(__x)));}
  static _Color_type& _S_color(_Base_ptr __x)
    { return (_Color_type&)(_Link_type(__x)->_M_color); }

  static _Link_type _S_minimum(_Link_type __x)
    { return (_Link_type) _Rb_tree_node_base::_S_minimum(__x); }

  static _Link_type _S_maximum(_Link_type __x)
    { return (_Link_type) _Rb_tree_node_base::_S_maximum(__x); }

public:
  typedef _Rb_tree_iterator<value_type, reference, pointer> iterator;
  typedef _Rb_tree_iterator<value_type, const_reference, const_pointer>
          const_iterator;

  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;

private:
  iterator _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
  _Link_type _M_copy(_Link_type __x, _Link_type __p);
  void _M_erase(_Link_type __x);

public:

  _Rb_tree()
    : _Base(allocator_type()), _M_node_count(0), _M_key_compare()
    { _M_empty_initialize(); }

  _Rb_tree(const _Compare& __comp)
    : _Base(allocator_type()), _M_node_count(0), _M_key_compare(__comp)
    { _M_empty_initialize(); }

  _Rb_tree(const _Compare& __comp, const allocator_type& __a)
    : _Base(__a), _M_node_count(0), _M_key_compare(__comp)
    { _M_empty_initialize(); }

  _Rb_tree(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x)
    : _Base(__x.get_allocator()),
      _M_node_count(0), _M_key_compare(__x._M_key_compare)
  {
    if (__x._M_root() == 0)
      _M_empty_initialize();
    else {
      _S_color(_M_header) = _S_rb_tree_red;
      _M_root() = _M_copy(__x._M_root(), _M_header);
      _M_leftmost() = _S_minimum(_M_root());
      _M_rightmost() = _S_maximum(_M_root());
    }
    _M_node_count = __x._M_node_count;
  }
  ~_Rb_tree() { clear(); }
  _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>&
  operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x);

private:
  void _M_empty_initialize() {
    _S_color(_M_header) = _S_rb_tree_red;

    _M_root() = 0;
    _M_leftmost() = _M_header;
    _M_rightmost() = _M_header;
  }

public:

  _Compare key_comp() const { return _M_key_compare; }
  iterator begin() { return _M_leftmost(); }
  const_iterator begin() const { return _M_leftmost(); }
  iterator end() { return _M_header; }
  const_iterator end() const { return _M_header; }
  reverse_iterator rbegin() { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const {
    return const_reverse_iterator(end());
  }
  reverse_iterator rend() { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const {
    return const_reverse_iterator(begin());
  }
  bool empty() const { return _M_node_count == 0; }
  size_type size() const { return _M_node_count; }
  size_type max_size() const { return size_type(-1); }

  void swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __t) {
    std::swap(_M_header, __t._M_header);
    std::swap(_M_node_count, __t._M_node_count);
    std::swap(_M_key_compare, __t._M_key_compare);
  }

public:

  pair<iterator,bool> insert_unique(const value_type& __x);
  iterator insert_equal(const value_type& __x);

  iterator insert_unique(iterator __position, const value_type& __x);
  iterator insert_equal(iterator __position, const value_type& __x);

  template <class _InputIterator>
  void insert_unique(_InputIterator __first, _InputIterator __last);
  template <class _InputIterator>
  void insert_equal(_InputIterator __first, _InputIterator __last);

  void erase(iterator __position);
  size_type erase(const key_type& __x);
  void erase(iterator __first, iterator __last);
  void erase(const key_type* __first, const key_type* __last);
  void clear() {
    if (_M_node_count != 0) {
      _M_erase(_M_root());
      _M_leftmost() = _M_header;
      _M_root() = 0;
      _M_rightmost() = _M_header;
      _M_node_count = 0;
    }
  }

public:

  iterator find(const key_type& __x);
  const_iterator find(const key_type& __x) const;
  size_type count(const key_type& __x) const;
  iterator lower_bound(const key_type& __x);
  const_iterator lower_bound(const key_type& __x) const;
  iterator upper_bound(const key_type& __x);
  const_iterator upper_bound(const key_type& __x) const;
  pair<iterator,iterator> equal_range(const key_type& __x);
  pair<const_iterator, const_iterator> equal_range(const key_type& __x) const;

public:

  bool __rb_verify() const;
};

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator==(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
  return __x.size() == __y.size() &&
         equal(__x.begin(), __x.end(), __y.begin());
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator<(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
          const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
  return lexicographical_compare(__x.begin(), __x.end(),
                                 __y.begin(), __y.end());
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator!=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator>(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
          const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator<=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator>=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}


template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline void
swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
     _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
  __x.swap(__y);
}


template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>&
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x)
{
  if (this != &__x) {

    clear();
    _M_node_count = 0;
    _M_key_compare = __x._M_key_compare;
    if (__x._M_root() == 0) {
      _M_root() = 0;
      _M_leftmost() = _M_header;
      _M_rightmost() = _M_header;
    }
    else {
      _M_root() = _M_copy(__x._M_root(), _M_header);
      _M_leftmost() = _S_minimum(_M_root());
      _M_rightmost() = _S_maximum(_M_root());
      _M_node_count = __x._M_node_count;
    }
  }
  return *this;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::_M_insert(_Base_ptr __x_, _Base_ptr __y_, const _Value& __v)
{
  _Link_type __x = (_Link_type) __x_;
  _Link_type __y = (_Link_type) __y_;
  _Link_type __z;

  if (__y == _M_header || __x != 0 ||
      _M_key_compare(_KeyOfValue()(__v), _S_key(__y))) {
    __z = _M_create_node(__v);
    _S_left(__y) = __z;

    if (__y == _M_header) {
      _M_root() = __z;
      _M_rightmost() = __z;
    }
    else if (__y == _M_leftmost())
      _M_leftmost() = __z;
  }
  else {
    __z = _M_create_node(__v);
    _S_right(__y) = __z;
    if (__y == _M_rightmost())
      _M_rightmost() = __z;
  }
  _S_parent(__z) = __y;
  _S_left(__z) = 0;
  _S_right(__z) = 0;
  _Rb_tree_rebalance(__z, _M_header->_M_parent);
  ++_M_node_count;
  return iterator(__z);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::insert_equal(const _Value& __v)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();
  while (__x != 0) {
    __y = __x;
    __x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
            _S_left(__x) : _S_right(__x);
  }
  return _M_insert(__x, __y, __v);
}


template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator,
     bool>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::insert_unique(const _Value& __v)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();
  bool __comp = true;
  while (__x != 0) {
    __y = __x;
    __comp = _M_key_compare(_KeyOfValue()(__v), _S_key(__x));
    __x = __comp ? _S_left(__x) : _S_right(__x);
  }
  iterator __j = iterator(__y);
  if (__comp)
    if (__j == begin())
      return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
    else
      --__j;
  if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
    return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
  return pair<iterator,bool>(__j, false);
}


template <class _Key, class _Val, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>
  ::insert_unique(iterator __position, const _Val& __v)
{
  if (__position._M_node == _M_header->_M_left) {
    if (size() > 0 &&
       _M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
      return _M_insert(__position._M_node, __position._M_node, __v);

    else
      return insert_unique(__v).first;
  } else if (__position._M_node == _M_header) {
    if (_M_key_compare(_S_key(_M_rightmost()), _KeyOfValue()(__v)))
      return _M_insert(0, _M_rightmost(), __v);
    else
      return insert_unique(__v).first;
  } else {
    iterator __before = __position;
    --__before;
    if (_M_key_compare(_S_key(__before._M_node), _KeyOfValue()(__v))
        && _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node))) {
      if (_S_right(__before._M_node) == 0)
        return _M_insert(0, __before._M_node, __v);
      else
        return _M_insert(__position._M_node, __position._M_node, __v);

    } else
      return insert_unique(__v).first;
  }
}

template <class _Key, class _Val, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>
  ::insert_equal(iterator __position, const _Val& __v)
{
  if (__position._M_node == _M_header->_M_left) {
    if (size() > 0 &&
        !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
      return _M_insert(__position._M_node, __position._M_node, __v);

    else
      return insert_equal(__v);
  } else if (__position._M_node == _M_header) {
    if (!_M_key_compare(_KeyOfValue()(__v), _S_key(_M_rightmost())))
      return _M_insert(0, _M_rightmost(), __v);
    else
      return insert_equal(__v);
  } else {
    iterator __before = __position;
    --__before;
    if (!_M_key_compare(_KeyOfValue()(__v), _S_key(__before._M_node))
        && !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v))) {
      if (_S_right(__before._M_node) == 0)
        return _M_insert(0, __before._M_node, __v);
      else
        return _M_insert(__position._M_node, __position._M_node, __v);

    } else
      return insert_equal(__v);
  }
}

template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
  template<class _II>
void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
  ::insert_equal(_II __first, _II __last)
{
  for ( ; __first != __last; ++__first)
    insert_equal(*__first);
}

template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
  template<class _II>
void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
  ::insert_unique(_II __first, _II __last) {
  for ( ; __first != __last; ++__first)
    insert_unique(*__first);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::erase(iterator __position)
{
  _Link_type __y =
    (_Link_type) _Rb_tree_rebalance_for_erase(__position._M_node,
                                              _M_header->_M_parent,
                                              _M_header->_M_left,
                                              _M_header->_M_right);
  destroy_node(__y);
  --_M_node_count;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::erase(const _Key& __x)
{
  pair<iterator,iterator> __p = equal_range(__x);
  size_type __n = 0;
  distance(__p.first, __p.second, __n);
  erase(__p.first, __p.second);
  return __n;
}

template <class _Key, class _Val, class _KoV, class _Compare, class _Alloc>
typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
_Rb_tree<_Key,_Val,_KoV,_Compare,_Alloc>
  ::_M_copy(_Link_type __x, _Link_type __p)
{

  _Link_type __top = _M_clone_node(__x);
  __top->_M_parent = __p;

  try {
    if (__x->_M_right)
      __top->_M_right = _M_copy(_S_right(__x), __top);
    __p = __top;
    __x = _S_left(__x);

    while (__x != 0) {
      _Link_type __y = _M_clone_node(__x);
      __p->_M_left = __y;
      __y->_M_parent = __p;
      if (__x->_M_right)
        __y->_M_right = _M_copy(_S_right(__x), __y);
      __p = __y;
      __x = _S_left(__x);
    }
  }
  catch(...) { _M_erase(__top); throw; };

  return __top;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::_M_erase(_Link_type __x)
{

  while (__x != 0) {
    _M_erase(_S_right(__x));
    _Link_type __y = _S_left(__x);
    destroy_node(__x);
    __x = __y;
  }
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::erase(iterator __first, iterator __last)
{
  if (__first == begin() && __last == end())
    clear();
  else
    while (__first != __last) erase(__first++);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::erase(const _Key* __first, const _Key* __last)
{
  while (__first != __last) erase(*__first++);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0)
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);

  iterator __j = iterator(__y);
  return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ?
     end() : __j;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k) const
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0) {
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);
  }
  const_iterator __j = const_iterator(__y);
  return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ?
    end() : __j;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::count(const _Key& __k) const
{
  pair<const_iterator, const_iterator> __p = equal_range(__k);
  size_type __n = 0;
  distance(__p.first, __p.second, __n);
  return __n;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::lower_bound(const _Key& __k)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0)
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);

  return iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::lower_bound(const _Key& __k) const
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0)
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);

  return const_iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::upper_bound(const _Key& __k)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

   while (__x != 0)
     if (_M_key_compare(__k, _S_key(__x)))
       __y = __x, __x = _S_left(__x);
     else
       __x = _S_right(__x);

   return iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::upper_bound(const _Key& __k) const
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

   while (__x != 0)
     if (_M_key_compare(__k, _S_key(__x)))
       __y = __x, __x = _S_left(__x);
     else
       __x = _S_right(__x);

   return const_iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline
pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator,
     typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::equal_range(const _Key& __k)
{
  return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k));
}

template <class _Key, class _Value, class _KoV, class _Compare, class _Alloc>
inline
pair<typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator,
     typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator>
_Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>
  ::equal_range(const _Key& __k) const
{
  return pair<const_iterator,const_iterator>(lower_bound(__k),
                                             upper_bound(__k));
}

inline int
__black_count(_Rb_tree_node_base* __node, _Rb_tree_node_base* __root)
{
  if (__node == 0)
    return 0;
  int __sum = 0;
  do {
    if (__node->_M_color == _S_rb_tree_black)
      ++__sum;
    if (__node == __root)
      break;
    __node = __node->_M_parent;
  } while (1);
  return __sum;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
bool _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
{
  if (_M_node_count == 0 || begin() == end())
    return _M_node_count == 0 && begin() == end() &&
      _M_header->_M_left == _M_header && _M_header->_M_right == _M_header;

  int __len = __black_count(_M_leftmost(), _M_root());
  for (const_iterator __it = begin(); __it != end(); ++__it) {
    _Link_type __x = (_Link_type) __it._M_node;
    _Link_type __L = _S_left(__x);
    _Link_type __R = _S_right(__x);

    if (__x->_M_color == _S_rb_tree_red)
      if ((__L && __L->_M_color == _S_rb_tree_red) ||
          (__R && __R->_M_color == _S_rb_tree_red))
        return false;

    if (__L && _M_key_compare(_S_key(__x), _S_key(__L)))
      return false;
    if (__R && _M_key_compare(_S_key(__R), _S_key(__x)))
      return false;

    if (!__L && !__R && __black_count(__x, _M_root()) != __len)
      return false;
  }

  if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
    return false;
  if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
    return false;

  return true;
}




template <class _Key, class _Value, class _KeyOfValue, class _Compare,
          class _Alloc = allocator<_Value> >
struct rb_tree : public _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc>
{
  typedef _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base;
  typedef typename _Base::allocator_type allocator_type;

  rb_tree(const _Compare& __comp = _Compare(),
          const allocator_type& __a = allocator_type())
    : _Base(__comp, __a) {}

  ~rb_tree() {}
};

}
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_map.h" 2 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_map.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_map.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/concept_check.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_map.h" 2 3

namespace std
{

template <class _Key, class _Tp, class _Compare = less<_Key>,
          class _Alloc = allocator<pair<const _Key, _Tp> > >
class map
{

                                                      ;
                                                                               ;

public:

  typedef _Key key_type;
  typedef _Tp data_type;
  typedef _Tp mapped_type;
  typedef pair<const _Key, _Tp> value_type;
  typedef _Compare key_compare;

  class value_compare
    : public binary_function<value_type, value_type, bool> {
  friend class map<_Key,_Tp,_Compare,_Alloc>;
  protected :
    _Compare comp;
    value_compare(_Compare __c) : comp(__c) {}
  public:
    bool operator()(const value_type& __x, const value_type& __y) const {
      return comp(__x.first, __y.first);
    }
  };

private:
  typedef _Rb_tree<key_type, value_type,
                   _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
  _Rep_type _M_t;
public:
  typedef typename _Rep_type::pointer pointer;
  typedef typename _Rep_type::const_pointer const_pointer;
  typedef typename _Rep_type::reference reference;
  typedef typename _Rep_type::const_reference const_reference;
  typedef typename _Rep_type::iterator iterator;
  typedef typename _Rep_type::const_iterator const_iterator;
  typedef typename _Rep_type::reverse_iterator reverse_iterator;
  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename _Rep_type::size_type size_type;
  typedef typename _Rep_type::difference_type difference_type;
  typedef typename _Rep_type::allocator_type allocator_type;



  map() : _M_t(_Compare(), allocator_type()) {}
  explicit map(const _Compare& __comp,
               const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) {}

  template <class _InputIterator>
  map(_InputIterator __first, _InputIterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_unique(__first, __last); }

  template <class _InputIterator>
  map(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
      const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
  map(const map<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}

  map<_Key,_Tp,_Compare,_Alloc>&
  operator=(const map<_Key, _Tp, _Compare, _Alloc>& __x)
  {
    _M_t = __x._M_t;
    return *this;
  }



  key_compare key_comp() const { return _M_t.key_comp(); }
  value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
  allocator_type get_allocator() const { return _M_t.get_allocator(); }

  iterator begin() { return _M_t.begin(); }
  const_iterator begin() const { return _M_t.begin(); }
  iterator end() { return _M_t.end(); }
  const_iterator end() const { return _M_t.end(); }
  reverse_iterator rbegin() { return _M_t.rbegin(); }
  const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
  reverse_iterator rend() { return _M_t.rend(); }
  const_reverse_iterator rend() const { return _M_t.rend(); }
  bool empty() const { return _M_t.empty(); }
  size_type size() const { return _M_t.size(); }
  size_type max_size() const { return _M_t.max_size(); }
  _Tp& operator[](const key_type& __k) {
    iterator __i = lower_bound(__k);

    if (__i == end() || key_comp()(__k, (*__i).first))
      __i = insert(__i, value_type(__k, _Tp()));
    return (*__i).second;
  }
  void swap(map<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }



  pair<iterator,bool> insert(const value_type& __x)
    { return _M_t.insert_unique(__x); }
  iterator insert(iterator position, const value_type& __x)
    { return _M_t.insert_unique(position, __x); }
  template <class _InputIterator>
  void insert(_InputIterator __first, _InputIterator __last) {
    _M_t.insert_unique(__first, __last);
  }

  void erase(iterator __position) { _M_t.erase(__position); }
  size_type erase(const key_type& __x) { return _M_t.erase(__x); }
  void erase(iterator __first, iterator __last)
    { _M_t.erase(__first, __last); }
  void clear() { _M_t.clear(); }



  iterator find(const key_type& __x) { return _M_t.find(__x); }
  const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
  size_type count(const key_type& __x) const {
    return _M_t.find(__x) == _M_t.end() ? 0 : 1;
  }
  iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
  const_iterator lower_bound(const key_type& __x) const {
    return _M_t.lower_bound(__x);
  }
  iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
  const_iterator upper_bound(const key_type& __x) const {
    return _M_t.upper_bound(__x);
  }

  pair<iterator,iterator> equal_range(const key_type& __x) {
    return _M_t.equal_range(__x);
  }
  pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
    return _M_t.equal_range(__x);
  }

  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator== (const map<_K1, _T1, _C1, _A1>&,
                          const map<_K1, _T1, _C1, _A1>&);
  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator< (const map<_K1, _T1, _C1, _A1>&,
                         const map<_K1, _T1, _C1, _A1>&);
};

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator==(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t == __y._M_t;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                      const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t < __y._M_t;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator!=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                      const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline void swap(map<_Key,_Tp,_Compare,_Alloc>& __x,
                 map<_Key,_Tp,_Compare,_Alloc>& __y) {
  __x.swap(__y);
}

}
# 65 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_map.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_multimap.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_multimap.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/concept_check.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_multimap.h" 2 3

namespace std
{



template <class _Key, class _Tp,
          class _Compare = less<_Key>,
          class _Alloc = allocator<pair<const _Key, _Tp> > >
class multimap;

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y);

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                      const multimap<_Key,_Tp,_Compare,_Alloc>& __y);

template <class _Key, class _Tp, class _Compare, class _Alloc>
class multimap
{

                                                      ;
                                                                               ;

public:



  typedef _Key key_type;
  typedef _Tp data_type;
  typedef _Tp mapped_type;
  typedef pair<const _Key, _Tp> value_type;
  typedef _Compare key_compare;

  class value_compare : public binary_function<value_type, value_type, bool> {
  friend class multimap<_Key,_Tp,_Compare,_Alloc>;
  protected:
    _Compare comp;
    value_compare(_Compare __c) : comp(__c) {}
  public:
    bool operator()(const value_type& __x, const value_type& __y) const {
      return comp(__x.first, __y.first);
    }
  };

private:
  typedef _Rb_tree<key_type, value_type,
                  _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
  _Rep_type _M_t;
public:
  typedef typename _Rep_type::pointer pointer;
  typedef typename _Rep_type::const_pointer const_pointer;
  typedef typename _Rep_type::reference reference;
  typedef typename _Rep_type::const_reference const_reference;
  typedef typename _Rep_type::iterator iterator;
  typedef typename _Rep_type::const_iterator const_iterator;
  typedef typename _Rep_type::reverse_iterator reverse_iterator;
  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename _Rep_type::size_type size_type;
  typedef typename _Rep_type::difference_type difference_type;
  typedef typename _Rep_type::allocator_type allocator_type;



  multimap() : _M_t(_Compare(), allocator_type()) { }
  explicit multimap(const _Compare& __comp,
                    const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { }

  template <class _InputIterator>
  multimap(_InputIterator __first, _InputIterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_equal(__first, __last); }

  template <class _InputIterator>
  multimap(_InputIterator __first, _InputIterator __last,
           const _Compare& __comp,
           const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
  multimap(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) { }

  multimap<_Key,_Tp,_Compare,_Alloc>&
  operator=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) {
    _M_t = __x._M_t;
    return *this;
  }



  key_compare key_comp() const { return _M_t.key_comp(); }
  value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
  allocator_type get_allocator() const { return _M_t.get_allocator(); }

  iterator begin() { return _M_t.begin(); }
  const_iterator begin() const { return _M_t.begin(); }
  iterator end() { return _M_t.end(); }
  const_iterator end() const { return _M_t.end(); }
  reverse_iterator rbegin() { return _M_t.rbegin(); }
  const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
  reverse_iterator rend() { return _M_t.rend(); }
  const_reverse_iterator rend() const { return _M_t.rend(); }
  bool empty() const { return _M_t.empty(); }
  size_type size() const { return _M_t.size(); }
  size_type max_size() const { return _M_t.max_size(); }
  void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }



  iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); }
  iterator insert(iterator __position, const value_type& __x) {
    return _M_t.insert_equal(__position, __x);
  }
  template <class _InputIterator>
  void insert(_InputIterator __first, _InputIterator __last) {
    _M_t.insert_equal(__first, __last);
  }
  void erase(iterator __position) { _M_t.erase(__position); }
  size_type erase(const key_type& __x) { return _M_t.erase(__x); }
  void erase(iterator __first, iterator __last)
    { _M_t.erase(__first, __last); }
  void clear() { _M_t.clear(); }



  iterator find(const key_type& __x) { return _M_t.find(__x); }
  const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
  size_type count(const key_type& __x) const { return _M_t.count(__x); }
  iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
  const_iterator lower_bound(const key_type& __x) const {
    return _M_t.lower_bound(__x);
  }
  iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
  const_iterator upper_bound(const key_type& __x) const {
    return _M_t.upper_bound(__x);
  }
   pair<iterator,iterator> equal_range(const key_type& __x) {
    return _M_t.equal_range(__x);
  }
  pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
    return _M_t.equal_range(__x);
  }

  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator== (const multimap<_K1, _T1, _C1, _A1>&,
                          const multimap<_K1, _T1, _C1, _A1>&);
  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator< (const multimap<_K1, _T1, _C1, _A1>&,
                         const multimap<_K1, _T1, _C1, _A1>&);
};

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t == __y._M_t;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                      const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t < __y._M_t;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                      const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                 multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  __x.swap(__y);
}

}
# 66 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_map.h" 2 3
# 32 "/usr/local/gcc-3.0.1/include/g++-v3/map" 2 3
# 3 "test.cpp" 2
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/iostream" 1 3
# 31 "/usr/local/gcc-3.0.1/include/g++-v3/iostream" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iostream.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iostream.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iostream.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ostream.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ostream.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/char_traits.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/char_traits.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstring.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/char_traits.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/fpos.h" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/char_traits.h" 2 3

namespace std
{



  template<class _CharT>
    struct char_traits
    {
      typedef _CharT char_type;

      typedef unsigned long int_type;
      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
        for (size_t __i = 0; __i < __n; ++__i)
          if (!eq(__s1[__i], __s2[__i]))
            return lt(__s1[__i], __s2[__i]) ? -1 : 1;
        return 0;
      }

      static size_t
      length(const char_type* __s)
      {
        const char_type* __p = __s;
        while (*__p) ++__p;
        return (__p - __s);
      }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
        for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
          if (*__p == __a) return __p;
        return 0;
      }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
        for (char_type* __p = __s; __p < __s + __n; ++__p)
          assign(*__p, __a);
        return __s;
      }

      static char_type
      to_char_type(const int_type& __c)
      { return char_type(__c); }

      static int_type
      to_int_type(const char_type& __c) { return int_type(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof() { return static_cast<int_type>(-1); }

      static int_type
      not_eof(const int_type& __c)
      { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
    };



  template<>
    struct char_traits<char>
    {
      typedef char char_type;
      typedef int int_type;
      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return memcmp(__s1, __s2, __n); }

      static size_t
      length(const char_type* __s)
      { return strlen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return static_cast<const char_type*>(memchr(__s, __a, __n)); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return static_cast<char_type*>(memset(__s, __a, __n)); }

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }



      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static int_type
      eof() { return static_cast<int_type>((-1)); }

      static int_type
      not_eof(const int_type& __c)
      { return (__c == eof()) ? 0 : __c; }
  };
# 264 "/usr/local/gcc-3.0.1/include/g++-v3/bits/char_traits.h" 3
  template<typename _CharT, typename _Traits>
    struct _Char_traits_match
    {
      _CharT _M_c;
      _Char_traits_match(_CharT const& __c) : _M_c(__c) { }

      bool
      operator()(_CharT const& __a) { return _Traits::eq(_M_c, __a); }
    };
}
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 1 3
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++locale.h" 1 3
# 36 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++locale.h" 3
namespace std
{
  typedef int* __c_locale;
}
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_climits.h" 1 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stringfwd.h" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/char_traits.h" 1 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 1 3
# 60 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 61 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 62 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_types.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_funcs.h" 1 3
# 65 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator.h" 1 3
# 66 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iterator.h" 2 3
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 1 3
# 48 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 1 3
# 50 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_alloc.h" 1 3
# 51 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_construct.h" 1 3
# 52 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_iterator_base_types.h" 1 3
# 53 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tempbuf.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tempbuf.h" 3
namespace std
{

template <class _Tp>
pair<_Tp*, ptrdiff_t>
__get_temporary_buffer(ptrdiff_t __len, _Tp*)
{
  if (__len > ptrdiff_t(2147483647 / sizeof(_Tp)))
    __len = 2147483647 / sizeof(_Tp);

  while (__len > 0) {
    _Tp* __tmp = (_Tp*) malloc((size_t)__len * sizeof(_Tp));
    if (__tmp != 0)
      return pair<_Tp*, ptrdiff_t>(__tmp, __len);
    __len /= 2;
  }

  return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0);
}

template <class _Tp>
inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) {
  return __get_temporary_buffer(__len, (_Tp*) 0);
}






template <class _Tp>
inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len, _Tp*) {
  return __get_temporary_buffer(__len, (_Tp*) 0);
}

template <class _Tp>
void return_temporary_buffer(_Tp* __p) {
  free(__p);
}

template <class _ForwardIterator, class _Tp>
class _Temporary_buffer {
private:
  ptrdiff_t _M_original_len;
  ptrdiff_t _M_len;
  _Tp* _M_buffer;

  void _M_allocate_buffer() {
    _M_original_len = _M_len;
    _M_buffer = 0;

    if (_M_len > (ptrdiff_t)(2147483647 / sizeof(_Tp)))
      _M_len = 2147483647 / sizeof(_Tp);

    while (_M_len > 0) {
      _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));
      if (_M_buffer)
        break;
      _M_len /= 2;
    }
  }

  void _M_initialize_buffer(const _Tp&, __true_type) {}
  void _M_initialize_buffer(const _Tp& val, __false_type) {
    uninitialized_fill_n(_M_buffer, _M_len, val);
  }

public:
  ptrdiff_t size() const { return _M_len; }
  ptrdiff_t requested_size() const { return _M_original_len; }
  _Tp* begin() { return _M_buffer; }
  _Tp* end() { return _M_buffer + _M_len; }

  _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {

    typedef typename __type_traits<_Tp>::has_trivial_default_constructor
            _Trivial;

    try {
      _M_len = 0;
      distance(__first, __last, _M_len);
      _M_allocate_buffer();
      if (_M_len > 0)
        _M_initialize_buffer(*__first, _Trivial());
    }
    catch(...) { free(_M_buffer); _M_buffer = 0; _M_len = 0; throw; };
  }

  ~_Temporary_buffer() {
    destroy(_M_buffer, _M_buffer + _M_len);
    free(_M_buffer);
  }

private:

  _Temporary_buffer(const _Temporary_buffer&) {}
  void operator=(const _Temporary_buffer&) {}
};



template <class _ForwardIterator,
          class _Tp
                    = typename iterator_traits<_ForwardIterator>::value_type
         >
struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
{
  temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
    : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) {}
  ~temporary_buffer() {}
};

}
# 54 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 55 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_raw_storage_iter.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_raw_storage_iter.h" 3
namespace std
{

template <class _ForwardIterator, class _Tp>
class raw_storage_iterator {
protected:
  _ForwardIterator _M_iter;
public:
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
  raw_storage_iterator& operator*() { return *this; }
  raw_storage_iterator& operator=(const _Tp& __element) {
    construct(&*_M_iter, __element);
    return *this;
  }
  raw_storage_iterator<_ForwardIterator, _Tp>& operator++() {
    ++_M_iter;
    return *this;
  }
  raw_storage_iterator<_ForwardIterator, _Tp> operator++(int) {
    raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
    ++_M_iter;
    return __tmp;
  }
};


}
# 56 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 2 3

namespace std
{

 template<class _Tp1> struct auto_ptr_ref {
   _Tp1* _M_ptr;
   auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}
};

template <class _Tp> class auto_ptr {
private:
  _Tp* _M_ptr;

public:
  typedef _Tp element_type;

  explicit auto_ptr(_Tp* __p = 0) throw() : _M_ptr(__p) {}
  auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) {}

  template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) throw()
    : _M_ptr(__a.release()) {}

  auto_ptr& operator=(auto_ptr& __a) throw() {
    reset(__a.release());
    return *this;
  }

  template <class _Tp1>
  auto_ptr& operator=(auto_ptr<_Tp1>& __a) throw() {
    reset(__a.release());
    return *this;
  }





  ~auto_ptr() { delete _M_ptr; }

  _Tp& operator*() const throw() {
    return *_M_ptr;
  }
  _Tp* operator->() const throw() {
    return _M_ptr;
  }
  _Tp* get() const throw() {
    return _M_ptr;
  }
  _Tp* release() throw() {
    _Tp* __tmp = _M_ptr;
    _M_ptr = 0;
    return __tmp;
  }
  void reset(_Tp* __p = 0) throw() {
    if (__p != _M_ptr) {
      delete _M_ptr;
      _M_ptr = __p;
    }
  }





public:
  auto_ptr(auto_ptr_ref<_Tp> __ref) throw()
    : _M_ptr(__ref._M_ptr) {}

  auto_ptr& operator=(auto_ptr_ref<_Tp> __ref) throw() {
    if (__ref._M_ptr != this->get()) {
      delete _M_ptr;
      _M_ptr = __ref._M_ptr;
    }
    return *this;
  }

  template <class _Tp1> operator auto_ptr_ref<_Tp1>() throw()
    { return auto_ptr_ref<_Tp>(this->release()); }
  template <class _Tp1> operator auto_ptr<_Tp1>() throw()
    { return auto_ptr<_Tp1>(this->release()); }
};

}
# 44 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/type_traits.h" 1 3
# 45 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 1 3
# 46 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/atomicity.h" 1 3
# 33 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/atomicity.h" 3
typedef int _Atomic_word;

static int
__attribute__ ((__unused__))
__exchange_and_add (volatile _Atomic_word* __mem, int __val)
{
  static unsigned char __lock;
  _Atomic_word __result, __tmp;

  __asm__ __volatile__("1:	ldstub	[%1], %0\n\t"
                       "	cmp	%0, 0\n\t"
                       "	bne	1b\n\t"
                       "	 nop"
                       : "=&r" (__tmp)
                       : "r" (&__lock)
                       : "memory");
  __result = *__mem;
  *__mem += __val;
  __asm__ __volatile__("stb	%%g0, [%0]"
                       :
                       : "r" (&__lock)
                       : "memory");
  return __result;
}

static void
__attribute__ ((__unused__))
__atomic_add (volatile _Atomic_word* __mem, int __val)
{
  static unsigned char __lock;
  _Atomic_word __tmp;

  __asm__ __volatile__("1:	ldstub	[%1], %0\n\t"
                       "	cmp	%0, 0\n\t"
                       "	bne	1b\n\t"
                       "	 nop"
                       : "=&r" (__tmp)
                       : "r" (&__lock)
                       : "memory");
  *__mem += __val;
  __asm__ __volatile__("stb	%%g0, [%0]"
                       :
                       : "r" (&__lock)
                       : "memory");
}

static int
__attribute__ ((__unused__))
__compare_and_swap (volatile long *__p, long __oldval, long __newval)
{
  static unsigned char __lock;
  long __ret, __tmp;

  __asm__ __volatile__("1:	ldstub	[%1], %0\n\t"
                       "	cmp	%0, 0\n\t"
                       "	bne	1b\n\t"
                       "	 nop"
                       : "=&r" (__tmp)
                       : "r" (&__lock)
                       : "memory");
  if (*__p != __oldval)
    __ret = 0;
  else
    {
      *__p = __newval;
      __ret = 1;
    }
  __asm__ __volatile__("stb	%%g0, [%0]"
                       :
                       : "r" (&__lock)
                       : "memory");

  return __ret;
}
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.h" 2 3

namespace std
{
# 83 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {

    public:
      typedef _Traits traits_type;
      typedef typename _Traits::char_type value_type;
      typedef _Alloc allocator_type;
      typedef typename _Alloc::size_type size_type;
      typedef typename _Alloc::difference_type difference_type;
      typedef typename _Alloc::reference reference;
      typedef typename _Alloc::const_reference const_reference;
      typedef typename _Alloc::pointer pointer;
      typedef typename _Alloc::const_pointer const_pointer;
      typedef __normal_iterator<pointer, basic_string> iterator;
      typedef __normal_iterator<const_pointer, basic_string> const_iterator;
      typedef reverse_iterator<const_iterator> const_reverse_iterator;
      typedef reverse_iterator<iterator> reverse_iterator;

    private:
# 118 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.h" 3
      struct _Rep
      {

        typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
# 136 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.h" 3
        static const size_type _S_max_size;
        static const _CharT _S_terminal;

        size_type _M_length;
        size_type _M_capacity;
        _Atomic_word _M_references;

        bool
        _M_is_leaked() const
        { return _M_references < 0; }

        bool
        _M_is_shared() const
        { return _M_references > 0; }

        void
        _M_set_leaked()
        { _M_references = -1; }

        void
        _M_set_sharable()
        { _M_references = 0; }

        _CharT*
        _M_refdata() throw()
        { return reinterpret_cast<_CharT*> (this + 1); }

        _CharT&
        operator[](size_t __s) throw()
        { return _M_refdata() [__s]; }

        _CharT*
        _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
        { return (!_M_is_leaked() && __alloc1 == __alloc2) ?
            _M_refcopy() : _M_clone(__alloc1); }


        static _Rep*
        _S_create(size_t, const _Alloc&);

        void
        _M_dispose(const _Alloc& __a)
        {
          if (__exchange_and_add(&_M_references, -1) <= 0)
            _M_destroy(__a);
        }

        void
        _M_destroy(const _Alloc&) throw();

        _CharT*
        _M_refcopy() throw()
        {
          __atomic_add(&_M_references, 1);
          return _M_refdata();
        }

        _CharT*
        _M_clone(const _Alloc&, size_type __res = 0);
# 208 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.h" 3
        inline static bool
        _S_excess_slop(size_t, size_t);

      };


      struct _Alloc_hider : _Alloc
      {
        _Alloc_hider(_CharT* __dat, const _Alloc& __a)
        : _Alloc(__a), _M_p(__dat) { }

        _CharT* _M_p;
      };

    public:



      static const size_type npos = static_cast<size_type>(-1);

    private:

      mutable _Alloc_hider _M_dataplus;



      static size_type _S_empty_rep_storage[(sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];

      _CharT*
      _M_data() const
      { return _M_dataplus._M_p; }

      _CharT*
      _M_data(_CharT* __p)
      { return (_M_dataplus._M_p = __p); }

      _Rep*
      _M_rep() const
      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }



      iterator
      _M_ibegin() const { return iterator(_M_data()); }

      iterator
      _M_iend() const { return iterator(_M_data() + this->size()); }

      void
      _M_leak()
      {
        if (!_M_rep()->_M_is_leaked())
          _M_leak_hard();
      }

      iterator
      _M_check(size_type __pos) const
      {
        if (__pos > this->size())
          __throw_out_of_range("basic_string::_M_check");
        return _M_ibegin() + __pos;
      }


      iterator
      _M_fold(size_type __pos, size_type __off) const
      {
        bool __testoff = __off < this->size() - __pos;
        size_type __newoff = __testoff ? __off : this->size() - __pos;
        return (_M_ibegin() + __pos + __newoff);
      }



      template<class _Iterator>
        static void
        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
        {
          for (; __k1 != __k2; ++__k1, ++__p)
            traits_type::assign(*__p, *__k1);
        }

      static void
      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
      { traits_type::copy(__p, __k1, __k2 - __k1); }

      static void
      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
      { traits_type::copy(__p, __k1, __k2 - __k1); }

      void
      _M_mutate(size_type __pos, size_type __len1, size_type __len2);

      void
      _M_leak_hard();

      static _Rep&
      _S_empty_rep()
      { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }

    public:




      inline
      basic_string();

      explicit
      basic_string(const _Alloc& __a);


      basic_string(const basic_string& __str);
      basic_string(const basic_string& __str, size_type __pos,
                   size_type __n = npos);
      basic_string(const basic_string& __str, size_type __pos,
                   size_type __n, const _Alloc& __a);

      basic_string(const _CharT* __s, size_type __n,
                   const _Alloc& __a = _Alloc());
      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());

      template<class _InputIterator>
        basic_string(_InputIterator __begin, _InputIterator __end,
                     const _Alloc& __a = _Alloc());

      ~basic_string()
      { _M_rep()->_M_dispose(this->get_allocator()); }

      basic_string&
      operator=(const basic_string& __str) { return this->assign(__str); }

      basic_string&
      operator=(const _CharT* __s) { return this->assign(__s); }

      basic_string&
      operator=(_CharT __c) { return this->assign(1, __c); }


      iterator
      begin()
      {
        _M_leak();
        return iterator(_M_data());
      }

      const_iterator
      begin() const
      { return const_iterator(_M_data()); }

      iterator
      end()
      {
         _M_leak();
         return iterator(_M_data() + this->size());
      }

      const_iterator
      end() const
      { return const_iterator(_M_data() + this->size()); }

      reverse_iterator
      rbegin()
      { return reverse_iterator(this->end()); }

      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(this->end()); }

      reverse_iterator
      rend()
      { return reverse_iterator(this->begin()); }

      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(this->begin()); }

    public:

      size_type
      size() const { return _M_rep()->_M_length; }

      size_type
      length() const { return _M_rep()->_M_length; }

      size_type
      max_size() const { return _Rep::_S_max_size; }

      void
      resize(size_type __n, _CharT __c);

      void
      resize(size_type __n) { this->resize(__n, _CharT()); }

      size_type
      capacity() const { return _M_rep()->_M_capacity; }

      void
      reserve(size_type __res_arg = 0);

      void
      clear() { _M_mutate(0, this->size(), 0); }

      bool
      empty() const { return this->size() == 0; }


      const_reference
      operator[] (size_type __pos) const
      { return _M_data()[__pos]; }

      reference
      operator[](size_type __pos)
      {
        _M_leak();
        return _M_data()[__pos];
      }

      const_reference
      at(size_type __n) const
      {
        if (__n >= this->size())
          __throw_out_of_range("basic_string::at");
        return _M_data()[__n];
      }

      reference
      at(size_type __n)
      {
        if (__n >= size())
          __throw_out_of_range("basic_string::at");
        _M_leak();
        return _M_data()[__n];
      }


      basic_string&
      operator+=(const basic_string& __str) { return this->append(__str); }

      basic_string&
      operator+=(const _CharT* __s) { return this->append(__s); }

      basic_string&
      operator+=(_CharT __c) { return this->append(size_type(1), __c); }

      basic_string&
      append(const basic_string& __str);

      basic_string&
      append(const basic_string& __str, size_type __pos, size_type __n);

      basic_string&
      append(const _CharT* __s, size_type __n);

      basic_string&
      append(const _CharT* __s)
      { return this->append(__s, traits_type::length(__s)); }

      basic_string&
      append(size_type __n, _CharT __c);

      template<class _InputIterator>
        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_iend(), _M_iend(), __first, __last); }

      void
      push_back(_CharT __c)
      { this->replace(_M_iend(), _M_iend(), 1, __c); }

      basic_string&
      assign(const basic_string& __str);

      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n)
      {
        return this->assign(__str._M_check(__pos), __str._M_fold(__pos, __n));
      }

      basic_string&
      assign(const _CharT* __s, size_type __n)
      { return this->assign(__s, __s + __n); }

      basic_string&
      assign(const _CharT* __s)
      { return this->assign(__s, __s + traits_type::length(__s)); }

      basic_string&
      assign(size_type __n, _CharT __c)
      { return this->replace(_M_ibegin(), _M_iend(), __n, __c); }

      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }

      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }

      template<class _InputIterator>
        void insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }

      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      {
        iterator __p = _M_check(__pos1);
        this->replace(__p, __p, __str._M_ibegin(), __str._M_iend());
        return *this;
      }

      basic_string&
      insert(size_type __pos1, const basic_string& __str,
             size_type __pos2, size_type __n)
      {
        iterator __p = _M_check(__pos1);
        this->replace(__p, __p, __str._M_check(__pos2),
                      __str._M_fold(__pos2, __n));
        return *this;
      }

      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n)
      {
        iterator __p = _M_check(__pos);
        this->replace(__p, __p, __s, __s + __n);
        return *this;
      }

      basic_string&
      insert(size_type __pos, const _CharT* __s)
      { return this->insert(__pos, __s, traits_type::length(__s)); }

      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      {
        this->insert(_M_check(__pos), __n, __c);
        return *this;
      }

      iterator
      insert(iterator __p, _CharT __c = _CharT())
      {
        size_type __pos = __p - _M_ibegin();
        this->insert(_M_check(__pos), size_type(1), __c);
        _M_rep()->_M_set_leaked();
        return this->_M_ibegin() + __pos;
      }

      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n),
                             _M_data(), _M_data());
      }

      iterator
      erase(iterator __position)
      {
        size_type __i = __position - _M_ibegin();
        this->replace(__position, __position + 1, _M_data(), _M_data());
        _M_rep()->_M_set_leaked();
        return _M_ibegin() + __i;
      }

      iterator
      erase(iterator __first, iterator __last)
      {
        size_type __i = __first - _M_ibegin();
        this->replace(__first, __last, _M_data(), _M_data());
        _M_rep()->_M_set_leaked();
       return _M_ibegin() + __i;
      }

      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n),
                              __str.begin(), __str.end());
      }

      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
              size_type __pos2, size_type __n2);

      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
              size_type __n2)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n1),
                             __s, __s + __n2);
      }

      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n1),
                             __s, __s + traits_type::length(__s));
      }

      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n1), __n2, __c);
      }

      basic_string&
      replace(iterator __i1, iterator __i2, const basic_string& __str)
      { return this->replace(__i1, __i2, __str.begin(), __str.end()); }

      basic_string&
      replace(iterator __i1, iterator __i2,
                           const _CharT* __s, size_type __n)
      { return this->replace(__i1, __i2, __s, __s + __n); }

      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s)
      { return this->replace(__i1, __i2, __s,
                             __s + traits_type::length(__s)); }

      basic_string&
      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c);

      template<class _InputIterator>
        basic_string&
        replace(iterator __i1, iterator __i2,
                _InputIterator __k1, _InputIterator __k2)
        { return _M_replace(__i1, __i2, __k1, __k2,
             typename iterator_traits<_InputIterator>::iterator_category()); }

    private:
      template<class _InputIterator>
        basic_string&
        _M_replace(iterator __i1, iterator __i2, _InputIterator __k1,
                   _InputIterator __k2, input_iterator_tag);

      template<class _FwdIterator>
        basic_string&
        _M_replace(iterator __i1, iterator __i2, _FwdIterator __k1,
                   _FwdIterator __k2, forward_iterator_tag);



      template<class _InIter>
        static _CharT*
        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
                         __false_type)
        {
          typedef typename iterator_traits<_InIter>::iterator_category _Tag;
          return _S_construct(__beg, __end, __a, _Tag());
        }

      template<class _InIter>
        static _CharT*
        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
                         __true_type)
        {
          return _S_construct(static_cast<size_type>(__beg),
                              static_cast<value_type>(__end), __a);
        }

      template<class _InIter>
        static _CharT*
        _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a)
        {
          typedef typename _Is_integer<_InIter>::_Integral _Integral;
          return _S_construct_aux(__beg, __end, __a, _Integral());
        }


      template<class _InIter>
        static _CharT*
         _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                      input_iterator_tag);



      template<class _FwdIter>
        static _CharT*
        _S_construct(_FwdIter __end, _FwdIter __beg, const _Alloc& __a,
                     forward_iterator_tag);

      static _CharT*
      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);

    public:

      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;

      void
      swap(basic_string<_CharT, _Traits, _Alloc>& __s);


      const _CharT*
      c_str() const
      {

        size_type __n = this->size();
        traits_type::assign(_M_data()[__n], _Rep::_S_terminal);
        return _M_data();
      }

      const _CharT*
      data() const { return _M_data(); }

      allocator_type
      get_allocator() const { return _M_dataplus; }

      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      { return this->find(__str.data(), __pos, __str.size()); }

      size_type
      find(const _CharT* __s, size_type __pos = 0) const
      { return this->find(__s, __pos, traits_type::length(__s)); }

      size_type
      find(_CharT __c, size_type __pos = 0) const;

      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      { return this->rfind(__str.data(), __pos, __str.size()); }

      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      { return this->rfind(__s, __pos, traits_type::length(__s)); }

      size_type
      rfind(_CharT __c, size_type __pos = npos) const;

      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_of(__str.data(), __pos, __str.size()); }

      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      { return this->find_first_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }

      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_of(__str.data(), __pos, __str.size()); }

      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      { return this->find_last_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }

      size_type
      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }

      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
                        size_type __n) const;

      size_type
      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
      { return this->find_first_not_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const;

      size_type
      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }

      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
                       size_type __n) const;
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
      { return this->find_last_not_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const;

      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      {
        if (__pos > this->size())
          __throw_out_of_range("basic_string::substr");
        return basic_string(*this, __pos, __n);
      }

      int
      compare(const basic_string& __str) const
      {
        size_type __size = this->size();
        size_type __osize = __str.size();
        size_type __len = min(__size, __osize);

        int __r = traits_type::compare(_M_data(), __str.data(), __len);
        if (!__r)
          __r = __size - __osize;
        return __r;
      }

      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;

      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
              size_type __pos2, size_type __n2) const;

      int
      compare(const _CharT* __s) const;



      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;

      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
              size_type __n2) const;

  };


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>::
    basic_string()
    : _M_dataplus(_S_empty_rep()._M_refcopy(), _Alloc()) { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
              const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
             const _CharT* __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str(__lhs);
      __str.append(__size_type(1), __rhs);
      return __str;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) == 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const _CharT* __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) == 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) == 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) != 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const _CharT* __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) != 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) != 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) < 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const _CharT* __rhs)
    { return __lhs.compare(__rhs) < 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const _CharT* __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) > 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) > 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const _CharT* __rhs)
    { return __lhs.compare(__rhs) > 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const _CharT* __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) < 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) <= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) <= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const _CharT* __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
  { return __rhs.compare(__lhs) >= 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) >= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) >= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const _CharT* __lhs,
             const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) <= 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline void
    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
         basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { __lhs.swap(__rhs); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is,
               basic_string<_CharT, _Traits, _Alloc>& __str);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const basic_string<_CharT, _Traits, _Alloc>& __str);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
            basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
            basic_string<_CharT, _Traits, _Alloc>& __str);
}
# 47 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3


# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_algorithm.h" 1 3
# 60 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_algorithm.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algobase.h" 1 3
# 62 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_construct.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_tempbuf.h" 1 3
# 65 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h" 1 3
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_heap.h" 1 3
# 62 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_heap.h" 3
namespace std
{



template <class _RandomAccessIterator, class _Distance, class _Tp>
void
__push_heap(_RandomAccessIterator __first,
            _Distance __holeIndex, _Distance __topIndex, _Tp __value)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
    *(__first + __holeIndex) = *(__first + __parent);
    __holeIndex = __parent;
    __parent = (__holeIndex - 1) / 2;
  }
  *(__first + __holeIndex) = __value;
}

template <class _RandomAccessIterator, class _Distance, class _Tp>
inline void
__push_heap_aux(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Distance*, _Tp*)
{
  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0),
              _Tp(*(__last - 1)));
}

template <class _RandomAccessIterator>
inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{

                               ;

                                                                     ;


  __push_heap_aux(__first, __last,
                  __distance_type(__first), __value_type(__first));
}

template <class _RandomAccessIterator, class _Distance, class _Tp,
          class _Compare>
void
__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
            _Distance __topIndex, _Tp __value, _Compare __comp)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
    *(__first + __holeIndex) = *(__first + __parent);
    __holeIndex = __parent;
    __parent = (__holeIndex - 1) / 2;
  }
  *(__first + __holeIndex) = __value;
}

template <class _RandomAccessIterator, class _Compare,
          class _Distance, class _Tp>
inline void
__push_heap_aux(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Compare __comp,
                _Distance*, _Tp*)
{
  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0),
              _Tp(*(__last - 1)), __comp);
}

template <class _RandomAccessIterator, class _Compare>
inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
          _Compare __comp)
{

                               ;


  __push_heap_aux(__first, __last, __comp,
                  __distance_type(__first), __value_type(__first));
}

template <class _RandomAccessIterator, class _Distance, class _Tp>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value)
{
  _Distance __topIndex = __holeIndex;
  _Distance __secondChild = 2 * __holeIndex + 2;
  while (__secondChild < __len) {
    if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
      __secondChild--;
    *(__first + __holeIndex) = *(__first + __secondChild);
    __holeIndex = __secondChild;
    __secondChild = 2 * (__secondChild + 1);
  }
  if (__secondChild == __len) {
    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
    __holeIndex = __secondChild - 1;
  }
  __push_heap(__first, __holeIndex, __topIndex, __value);
}

template <class _RandomAccessIterator, class _Tp, class _Distance>
inline void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
           _RandomAccessIterator __result, _Tp __value, _Distance*)
{
  *__result = *__first;
  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
}

template <class _RandomAccessIterator, class _Tp>
inline void
__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last,
               _Tp*)
{
  __pop_heap(__first, __last - 1, __last - 1,
             _Tp(*(__last - 1)), __distance_type(__first));
}

template <class _RandomAccessIterator>
inline void pop_heap(_RandomAccessIterator __first,
                     _RandomAccessIterator __last)
{

                               ;

                                                                     ;


  __pop_heap_aux(__first, __last, __value_type(__first));
}

template <class _RandomAccessIterator, class _Distance,
          class _Tp, class _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value, _Compare __comp)
{
  _Distance __topIndex = __holeIndex;
  _Distance __secondChild = 2 * __holeIndex + 2;
  while (__secondChild < __len) {
    if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
      __secondChild--;
    *(__first + __holeIndex) = *(__first + __secondChild);
    __holeIndex = __secondChild;
    __secondChild = 2 * (__secondChild + 1);
  }
  if (__secondChild == __len) {
    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
    __holeIndex = __secondChild - 1;
  }
  __push_heap(__first, __holeIndex, __topIndex, __value, __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Compare,
          class _Distance>
inline void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
           _RandomAccessIterator __result, _Tp __value, _Compare __comp,
           _Distance*)
{
  *__result = *__first;
  __adjust_heap(__first, _Distance(0), _Distance(__last - __first),
                __value, __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Compare>
inline void
__pop_heap_aux(_RandomAccessIterator __first,
               _RandomAccessIterator __last, _Tp*, _Compare __comp)
{
  __pop_heap(__first, __last - 1, __last - 1, _Tp(*(__last - 1)), __comp,
             __distance_type(__first));
}

template <class _RandomAccessIterator, class _Compare>
inline void
pop_heap(_RandomAccessIterator __first,
         _RandomAccessIterator __last, _Compare __comp)
{

                               ;


  __pop_heap_aux(__first, __last, __value_type(__first), __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Distance>
void
__make_heap(_RandomAccessIterator __first,
            _RandomAccessIterator __last, _Tp*, _Distance*)
{
  if (__last - __first < 2) return;
  _Distance __len = __last - __first;
  _Distance __parent = (__len - 2)/2;

  while (true) {
    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)));
    if (__parent == 0) return;
    __parent--;
  }
}

template <class _RandomAccessIterator>
inline void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{

                               ;

                                                                     ;


  __make_heap(__first, __last,
              __value_type(__first), __distance_type(__first));
}

template <class _RandomAccessIterator, class _Compare,
          class _Tp, class _Distance>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
            _Compare __comp, _Tp*, _Distance*)
{
  if (__last - __first < 2) return;
  _Distance __len = __last - __first;
  _Distance __parent = (__len - 2)/2;

  while (true) {
    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)),
                  __comp);
    if (__parent == 0) return;
    __parent--;
  }
}

template <class _RandomAccessIterator, class _Compare>
inline void
make_heap(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
{

                               ;


  __make_heap(__first, __last, __comp,
              __value_type(__first), __distance_type(__first));
}

template <class _RandomAccessIterator>
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{

                               ;

                                                                     ;


  while (__last - __first > 1)
    pop_heap(__first, __last--);
}

template <class _RandomAccessIterator, class _Compare>
void
sort_heap(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
{

                               ;


  while (__last - __first > 1)
    pop_heap(__first, __last--, __comp);
}

}
# 64 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h" 2 3



namespace std
{



template <class _Tp>
inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
{

                                                              ;
  if (__a < __b)
    if (__b < __c)
      return __b;
    else if (__a < __c)
      return __c;
    else
      return __a;
  else if (__a < __c)
    return __a;
  else if (__b < __c)
    return __c;
  else
    return __b;
}

template <class _Tp, class _Compare>
inline const _Tp&
__median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
{

                                                                               ;
  if (__comp(__a, __b))
    if (__comp(__b, __c))
      return __b;
    else if (__comp(__a, __c))
      return __c;
    else
      return __a;
  else if (__comp(__a, __c))
    return __a;
  else if (__comp(__b, __c))
    return __c;
  else
    return __b;
}


template <class _InputIter, class _Function>
_Function for_each(_InputIter __first, _InputIter __last, _Function __f)
{

                                                                ;
  for ( ; __first != __last; ++__first)
    __f(*__first);
  return __f;
}



template <class _InputIter, class _Tp>
inline _InputIter find(_InputIter __first, _InputIter __last,
                       const _Tp& __val,
                       input_iterator_tag)
{
  while (__first != __last && !(*__first == __val))
    ++__first;
  return __first;
}

template <class _InputIter, class _Predicate>
inline _InputIter find_if(_InputIter __first, _InputIter __last,
                          _Predicate __pred,
                          input_iterator_tag)
{
  while (__first != __last && !__pred(*__first))
    ++__first;
  return __first;
}

template <class _RandomAccessIter, class _Tp>
_RandomAccessIter find(_RandomAccessIter __first, _RandomAccessIter __last,
                       const _Tp& __val,
                       random_access_iterator_tag)
{
  typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
    = (__last - __first) >> 2;

  for ( ; __trip_count > 0 ; --__trip_count) {
    if (*__first == __val) return __first;
    ++__first;

    if (*__first == __val) return __first;
    ++__first;

    if (*__first == __val) return __first;
    ++__first;

    if (*__first == __val) return __first;
    ++__first;
  }

  switch(__last - __first) {
  case 3:
    if (*__first == __val) return __first;
    ++__first;
  case 2:
    if (*__first == __val) return __first;
    ++__first;
  case 1:
    if (*__first == __val) return __first;
    ++__first;
  case 0:
  default:
    return __last;
  }
}

template <class _RandomAccessIter, class _Predicate>
_RandomAccessIter find_if(_RandomAccessIter __first, _RandomAccessIter __last,
                          _Predicate __pred,
                          random_access_iterator_tag)
{
  typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
    = (__last - __first) >> 2;

  for ( ; __trip_count > 0 ; --__trip_count) {
    if (__pred(*__first)) return __first;
    ++__first;

    if (__pred(*__first)) return __first;
    ++__first;

    if (__pred(*__first)) return __first;
    ++__first;

    if (__pred(*__first)) return __first;
    ++__first;
  }

  switch(__last - __first) {
  case 3:
    if (__pred(*__first)) return __first;
    ++__first;
  case 2:
    if (__pred(*__first)) return __first;
    ++__first;
  case 1:
    if (__pred(*__first)) return __first;
    ++__first;
  case 0:
  default:
    return __last;
  }
}

template <class _InputIter, class _Tp>
inline _InputIter find(_InputIter __first, _InputIter __last,
                       const _Tp& __val)
{

                                                                ;
                                                                   ;

  return find(__first, __last, __val, __iterator_category(__first));
}

template <class _InputIter, class _Predicate>
inline _InputIter find_if(_InputIter __first, _InputIter __last,
                          _Predicate __pred)
{

                                                                ;
                                                            ;

  return find_if(__first, __last, __pred, __iterator_category(__first));
}



template <class _ForwardIter>
_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last)
{

                                                                    ;
                                                            ;

  if (__first == __last)
    return __last;
  _ForwardIter __next = __first;
  while(++__next != __last) {
    if (*__first == *__next)
      return __first;
    __first = __next;
  }
  return __last;
}

template <class _ForwardIter, class _BinaryPredicate>
_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last,
                           _BinaryPredicate __binary_pred)
{

                                                                    ;
                                                            ;


  if (__first == __last)
    return __last;
  _ForwardIter __next = __first;
  while(++__next != __last) {
    if (__binary_pred(*__first, *__next))
      return __first;
    __first = __next;
  }
  return __last;
}







template <class _InputIter, class _Tp, class _Size>
void count(_InputIter __first, _InputIter __last, const _Tp& __value,
           _Size& __n)
{

                                                                ;
                                                           ;

                                                              ;
  for ( ; __first != __last; ++__first)
    if (*__first == __value)
      ++__n;
}

template <class _InputIter, class _Predicate, class _Size>
void count_if(_InputIter __first, _InputIter __last, _Predicate __pred,
              _Size& __n)
{

                                                                ;
                                                          ;

  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      ++__n;
}

template <class _InputIter, class _Tp>
typename iterator_traits<_InputIter>::difference_type
count(_InputIter __first, _InputIter __last, const _Tp& __value)
{

                                                                ;
                                                           ;

                                                              ;
  typename iterator_traits<_InputIter>::difference_type __n = 0;
  for ( ; __first != __last; ++__first)
    if (*__first == __value)
      ++__n;
  return __n;
}

template <class _InputIter, class _Predicate>
typename iterator_traits<_InputIter>::difference_type
count_if(_InputIter __first, _InputIter __last, _Predicate __pred)
{

                                                                ;
                                                          ;

  typename iterator_traits<_InputIter>::difference_type __n = 0;
  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      ++__n;
  return __n;
}




template <class _ForwardIter1, class _ForwardIter2>
_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
                     _ForwardIter2 __first2, _ForwardIter2 __last2)
{

                                                                     ;
                                                                     ;
                                                             ;




  if (__first1 == __last1 || __first2 == __last2)
    return __first1;


  _ForwardIter2 __tmp(__first2);
  ++__tmp;
  if (__tmp == __last2)
    return find(__first1, __last1, *__first2);



  _ForwardIter2 __p1, __p;

  __p1 = __first2; ++__p1;

  _ForwardIter1 __current = __first1;

  while (__first1 != __last1) {
    __first1 = find(__first1, __last1, *__first2);
    if (__first1 == __last1)
      return __last1;

    __p = __p1;
    __current = __first1;
    if (++__current == __last1)
      return __last1;

    while (*__current == *__p) {
      if (++__p == __last2)
        return __first1;
      if (++__current == __last1)
        return __last1;
    }

    ++__first1;
  }
  return __first1;
}

template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
                     _ForwardIter2 __first2, _ForwardIter2 __last2,
                     _BinaryPred __predicate)
{

                                                                     ;
                                                                     ;
                                                             ;




  if (__first1 == __last1 || __first2 == __last2)
    return __first1;


  _ForwardIter2 __tmp(__first2);
  ++__tmp;
  if (__tmp == __last2) {
    while (__first1 != __last1 && !__predicate(*__first1, *__first2))
      ++__first1;
    return __first1;
  }



  _ForwardIter2 __p1, __p;

  __p1 = __first2; ++__p1;

  _ForwardIter1 __current = __first1;

  while (__first1 != __last1) {
    while (__first1 != __last1) {
      if (__predicate(*__first1, *__first2))
        break;
      ++__first1;
    }
    while (__first1 != __last1 && !__predicate(*__first1, *__first2))
      ++__first1;
    if (__first1 == __last1)
      return __last1;

    __p = __p1;
    __current = __first1;
    if (++__current == __last1) return __last1;

    while (__predicate(*__current, *__p)) {
      if (++__p == __last2)
        return __first1;
      if (++__current == __last1)
        return __last1;
    }

    ++__first1;
  }
  return __first1;
}



template <class _ForwardIter, class _Integer, class _Tp>
_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
                      _Integer __count, const _Tp& __val)
{

                                                                    ;
                                                            ;

                                                              ;

  if (__count <= 0)
    return __first;
  else {
    __first = find(__first, __last, __val);
    while (__first != __last) {
      _Integer __n = __count - 1;
      _ForwardIter __i = __first;
      ++__i;
      while (__i != __last && __n != 0 && *__i == __val) {
        ++__i;
        --__n;
      }
      if (__n == 0)
        return __first;
      else
        __first = find(__i, __last, __val);
    }
    return __last;
  }
}

template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
                      _Integer __count, const _Tp& __val,
                      _BinaryPred __binary_pred)
{

                                                                    ;
                                                                 ;


  if (__count <= 0)
    return __first;
  else {
    while (__first != __last) {
      if (__binary_pred(*__first, __val))
        break;
      ++__first;
    }
    while (__first != __last) {
      _Integer __n = __count - 1;
      _ForwardIter __i = __first;
      ++__i;
      while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {
        ++__i;
        --__n;
      }
      if (__n == 0)
        return __first;
      else {
        while (__i != __last) {
          if (__binary_pred(*__i, __val))
            break;
          ++__i;
        }
        __first = __i;
      }
    }
    return __last;
  }
}



template <class _ForwardIter1, class _ForwardIter2>
_ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
                          _ForwardIter2 __first2)
{

                                                                             ;
                                                                             ;
                                                             ;


                                                             ;



  for ( ; __first1 != __last1; ++__first1, ++__first2)
    iter_swap(__first1, __first2);
  return __first2;
}



template <class _InputIter, class _OutputIter, class _UnaryOperation>
_OutputIter transform(_InputIter __first, _InputIter __last,
                      _OutputIter __result, _UnaryOperation __unary_op)
{

                                                                ;






  for ( ; __first != __last; ++__first, ++__result)
    *__result = __unary_op(*__first);
  return __result;
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _BinaryOperation>
_OutputIter transform(_InputIter1 __first1, _InputIter1 __last1,
                      _InputIter2 __first2, _OutputIter __result,
                      _BinaryOperation __binary_op)
{

                                                                 ;
                                                                 ;






  for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
    *__result = __binary_op(*__first1, *__first2);
  return __result;
}



template <class _ForwardIter, class _Tp>
void replace(_ForwardIter __first, _ForwardIter __last,
             const _Tp& __old_value, const _Tp& __new_value)
{

                                                                            ;
                                                                 ;

                                                            ;


  for ( ; __first != __last; ++__first)
    if (*__first == __old_value)
      *__first = __new_value;
}

template <class _ForwardIter, class _Predicate, class _Tp>
void replace_if(_ForwardIter __first, _ForwardIter __last,
                _Predicate __pred, const _Tp& __new_value)
{

                                                                            ;
                                                            ;

                                                            ;


  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      *__first = __new_value;
}

template <class _InputIter, class _OutputIter, class _Tp>
_OutputIter replace_copy(_InputIter __first, _InputIter __last,
                         _OutputIter __result,
                         const _Tp& __old_value, const _Tp& __new_value)
{

                                                                ;
                                                          ;

                                                               ;


  for ( ; __first != __last; ++__first, ++__result)
    *__result = *__first == __old_value ? __new_value : *__first;
  return __result;
}

template <class _InputIter, class _OutputIter, class _Predicate, class _Tp>
_OutputIter replace_copy_if(_InputIter __first, _InputIter __last,
                            _OutputIter __result,
                            _Predicate __pred, const _Tp& __new_value)
{

                                                                ;
                                                          ;

                                                          ;


  for ( ; __first != __last; ++__first, ++__result)
    *__result = __pred(*__first) ? __new_value : *__first;
  return __result;
}



template <class _ForwardIter, class _Generator>
void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
{

                                                                    ;
                                                            ;


  for ( ; __first != __last; ++__first)
    *__first = __gen();
}

template <class _OutputIter, class _Size, class _Generator>
_OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen)
{






  for ( ; __n > 0; --__n, ++__first)
    *__first = __gen();
  return __first;
}



template <class _InputIter, class _OutputIter, class _Tp>
_OutputIter remove_copy(_InputIter __first, _InputIter __last,
                        _OutputIter __result, const _Tp& __value)
{

                                                                ;
                                                          ;

                                                               ;


  for ( ; __first != __last; ++__first)
    if (!(*__first == __value)) {
      *__result = *__first;
      ++__result;
    }
  return __result;
}

template <class _InputIter, class _OutputIter, class _Predicate>
_OutputIter remove_copy_if(_InputIter __first, _InputIter __last,
                           _OutputIter __result, _Predicate __pred)
{

                                                                ;
                                                          ;

                                                          ;


  for ( ; __first != __last; ++__first)
    if (!__pred(*__first)) {
      *__result = *__first;
      ++__result;
    }
  return __result;
}

template <class _ForwardIter, class _Tp>
_ForwardIter remove(_ForwardIter __first, _ForwardIter __last,
                    const _Tp& __value)
{

                                                                            ;
                                                            ;

                                                                 ;


  __first = find(__first, __last, __value);
  _ForwardIter __i = __first;
  return __first == __last ? __first
                           : remove_copy(++__i, __last, __first, __value);
}

template <class _ForwardIter, class _Predicate>
_ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last,
                       _Predicate __pred)
{

                                                                            ;
                                                            ;


  __first = find_if(__first, __last, __pred);
  _ForwardIter __i = __first;
  return __first == __last ? __first
                           : remove_copy_if(++__i, __last, __first, __pred);
}



template <class _InputIter, class _OutputIter, class _Tp>
_OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                          _OutputIter __result, _Tp*)
{

  _Tp __value = *__first;
  *__result = __value;
  while (++__first != __last)
    if (!(__value == *__first)) {
      __value = *__first;
      *++__result = __value;
    }
  return ++__result;
}

template <class _InputIter, class _OutputIter>
inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                                 _OutputIter __result,
                                 output_iterator_tag)
{

  return __unique_copy(__first, __last, __result, __value_type(__first));
}

template <class _InputIter, class _ForwardIter>
_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
                           _ForwardIter __result, forward_iterator_tag)
{

  *__result = *__first;
  while (++__first != __last)
    if (!(*__result == *__first))
      *++__result = *__first;
  return ++__result;
}

template <class _InputIter, class _OutputIter>
inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
                               _OutputIter __result)
{

                                                                ;
                                                          ;

                                                          ;


  if (__first == __last) return __result;
  return __unique_copy(__first, __last, __result,
                       __iterator_category(__result));
}

template <class _InputIter, class _OutputIter, class _BinaryPredicate,
          class _Tp>
_OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                          _OutputIter __result,
                          _BinaryPredicate __binary_pred, _Tp*)
{

                                                                                  ;

  _Tp __value = *__first;
  *__result = __value;
  while (++__first != __last)
    if (!__binary_pred(__value, *__first)) {
      __value = *__first;
      *++__result = __value;
    }
  return ++__result;
}

template <class _InputIter, class _OutputIter, class _BinaryPredicate>
inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                                 _OutputIter __result,
                                 _BinaryPredicate __binary_pred,
                                 output_iterator_tag)
{

  return __unique_copy(__first, __last, __result, __binary_pred,
                       __value_type(__first));
}

template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
                           _ForwardIter __result,
                           _BinaryPredicate __binary_pred,
                           forward_iterator_tag)
{

                                                          ;



  *__result = *__first;
  while (++__first != __last)
    if (!__binary_pred(*__result, *__first)) *++__result = *__first;
  return ++__result;
}

template <class _InputIter, class _OutputIter, class _BinaryPredicate>
inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
                               _OutputIter __result,
                               _BinaryPredicate __binary_pred)
{

                                                                ;
                                                          ;


  if (__first == __last) return __result;
  return __unique_copy(__first, __last, __result, __binary_pred,
                       __iterator_category(__result));
}

template <class _ForwardIter>
_ForwardIter unique(_ForwardIter __first, _ForwardIter __last)
{

                                                                            ;
                                                            ;


  __first = adjacent_find(__first, __last);
  return unique_copy(__first, __last, __first);
}

template <class _ForwardIter, class _BinaryPredicate>
_ForwardIter unique(_ForwardIter __first, _ForwardIter __last,
                    _BinaryPredicate __binary_pred)
{

                                                                            ;
                                                            ;



  __first = adjacent_find(__first, __last, __binary_pred);
  return unique_copy(__first, __last, __first, __binary_pred);
}



template <class _BidirectionalIter>
void __reverse(_BidirectionalIter __first, _BidirectionalIter __last,
               bidirectional_iterator_tag) {
  while (true)
    if (__first == __last || __first == --__last)
      return;
    else
      iter_swap(__first++, __last);
}

template <class _RandomAccessIter>
void __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
               random_access_iterator_tag) {
  while (__first < __last)
    iter_swap(__first++, --__last);
}

template <class _BidirectionalIter>
inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last)
{

                            ;

  __reverse(__first, __last, __iterator_category(__first));
}

template <class _BidirectionalIter, class _OutputIter>
_OutputIter reverse_copy(_BidirectionalIter __first,
                         _BidirectionalIter __last,
                         _OutputIter __result)
{

                                                                                ;
                                                                  ;


  while (__first != __last) {
    --__last;
    *__result = *__last;
    ++__result;
  }
  return __result;
}



template <class _EuclideanRingElement>
_EuclideanRingElement __gcd(_EuclideanRingElement __m,
                            _EuclideanRingElement __n)
{
  while (__n != 0) {
    _EuclideanRingElement __t = __m % __n;
    __m = __n;
    __n = __t;
  }
  return __m;
}

template <class _ForwardIter, class _Distance>
_ForwardIter __rotate(_ForwardIter __first,
                      _ForwardIter __middle,
                      _ForwardIter __last,
                      _Distance*,
                      forward_iterator_tag)
{
  if (__first == __middle)
    return __last;
  if (__last == __middle)
    return __first;

  _ForwardIter __first2 = __middle;
  do {
    swap(*__first++, *__first2++);
    if (__first == __middle)
      __middle = __first2;
  } while (__first2 != __last);

  _ForwardIter __new_middle = __first;

  __first2 = __middle;

  while (__first2 != __last) {
    swap (*__first++, *__first2++);
    if (__first == __middle)
      __middle = __first2;
    else if (__first2 == __last)
      __first2 = __middle;
  }

  return __new_middle;
}


template <class _BidirectionalIter, class _Distance>
_BidirectionalIter __rotate(_BidirectionalIter __first,
                            _BidirectionalIter __middle,
                            _BidirectionalIter __last,
                            _Distance*,
                            bidirectional_iterator_tag)
{

                            ;


  if (__first == __middle)
    return __last;
  if (__last == __middle)
    return __first;

  __reverse(__first, __middle, bidirectional_iterator_tag());
  __reverse(__middle, __last, bidirectional_iterator_tag());

  while (__first != __middle && __middle != __last)
    swap (*__first++, *--__last);

  if (__first == __middle) {
    __reverse(__middle, __last, bidirectional_iterator_tag());
    return __last;
  }
  else {
    __reverse(__first, __middle, bidirectional_iterator_tag());
    return __first;
  }
}

template <class _RandomAccessIter, class _Distance, class _Tp>
_RandomAccessIter __rotate(_RandomAccessIter __first,
                           _RandomAccessIter __middle,
                           _RandomAccessIter __last,
                           _Distance *, _Tp *)
{

                           ;


  _Distance __n = __last - __first;
  _Distance __k = __middle - __first;
  _Distance __l = __n - __k;
  _RandomAccessIter __result = __first + (__last - __middle);

  if (__k == 0)
    return __last;

  else if (__k == __l) {
    swap_ranges(__first, __middle, __middle);
    return __result;
  }

  _Distance __d = __gcd(__n, __k);

  for (_Distance __i = 0; __i < __d; __i++) {
    _Tp __tmp = *__first;
    _RandomAccessIter __p = __first;

    if (__k < __l) {
      for (_Distance __j = 0; __j < __l/__d; __j++) {
        if (__p > __first + __l) {
          *__p = *(__p - __l);
          __p -= __l;
        }

        *__p = *(__p + __k);
        __p += __k;
      }
    }

    else {
      for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {
        if (__p < __last - __k) {
          *__p = *(__p + __k);
          __p += __k;
        }

        *__p = * (__p - __l);
        __p -= __l;
      }
    }

    *__p = __tmp;
    ++__first;
  }

  return __result;
}

template <class _ForwardIter>
inline _ForwardIter rotate(_ForwardIter __first, _ForwardIter __middle,
                           _ForwardIter __last)
{

                                                                            ;

  return __rotate(__first, __middle, __last,
                  __distance_type(__first),
                  __iterator_category(__first));
}

template <class _ForwardIter, class _OutputIter>
_OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,
                        _ForwardIter __last, _OutputIter __result)
{

                                                                    ;
                                                            ;


  return copy(__first, __middle, copy(__middle, __last, __result));
}




template <class _Distance>
inline _Distance __random_number(_Distance __n) {

  return lrand48() % __n;



}



template <class _RandomAccessIter>
inline void random_shuffle(_RandomAccessIter __first,
                           _RandomAccessIter __last)
{

                           ;


  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + __random_number((__i - __first) + 1));
}

template <class _RandomAccessIter, class _RandomNumberGenerator>
void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
                    _RandomNumberGenerator& __rand)
{

                           ;


  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + __rand((__i - __first) + 1));
}



template <class _ForwardIter, class _OutputIter, class _Distance>
_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
                            _OutputIter __out, const _Distance __n)
{

                                                                    ;
                                                            ;


  _Distance __remaining = 0;
  distance(__first, __last, __remaining);
  _Distance __m = min(__n, __remaining);

  while (__m > 0) {
    if (__random_number(__remaining) < __m) {
      *__out = *__first;
      ++__out;
      --__m;
    }

    --__remaining;
    ++__first;
  }
  return __out;
}

template <class _ForwardIter, class _OutputIter, class _Distance,
          class _RandomNumberGenerator>
_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
                            _OutputIter __out, const _Distance __n,
                            _RandomNumberGenerator& __rand)
{

                                                                    ;
                                                            ;

                                                      ;


  _Distance __remaining = 0;
  distance(__first, __last, __remaining);
  _Distance __m = min(__n, __remaining);

  while (__m > 0) {
    if (__rand(__remaining) < __m) {
      *__out = *__first;
      ++__out;
      --__m;
    }

    --__remaining;
    ++__first;
  }
  return __out;
}

template <class _InputIter, class _RandomAccessIter, class _Distance>
_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
                                  _RandomAccessIter __out,
                                  const _Distance __n)
{
  _Distance __m = 0;
  _Distance __t = __n;
  for ( ; __first != __last && __m < __n; ++__m, ++__first)
    __out[__m] = *__first;

  while (__first != __last) {
    ++__t;
    _Distance __M = __random_number(__t);
    if (__M < __n)
      __out[__M] = *__first;
    ++__first;
  }

  return __out + __m;
}

template <class _InputIter, class _RandomAccessIter,
          class _RandomNumberGenerator, class _Distance>
_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
                                  _RandomAccessIter __out,
                                  _RandomNumberGenerator& __rand,
                                  const _Distance __n)
{

                                                      ;


  _Distance __m = 0;
  _Distance __t = __n;
  for ( ; __first != __last && __m < __n; ++__m, ++__first)
    __out[__m] = *__first;

  while (__first != __last) {
    ++__t;
    _Distance __M = __rand(__t);
    if (__M < __n)
      __out[__M] = *__first;
    ++__first;
  }

  return __out + __m;
}

template <class _InputIter, class _RandomAccessIter>
inline _RandomAccessIter
random_sample(_InputIter __first, _InputIter __last,
              _RandomAccessIter __out_first, _RandomAccessIter __out_last)
{

                                                                ;
                           ;


  return __random_sample(__first, __last,
                         __out_first, __out_last - __out_first);
}


template <class _InputIter, class _RandomAccessIter,
          class _RandomNumberGenerator>
inline _RandomAccessIter
random_sample(_InputIter __first, _InputIter __last,
              _RandomAccessIter __out_first, _RandomAccessIter __out_last,
              _RandomNumberGenerator& __rand)
{

                                                                ;
                           ;


  return __random_sample(__first, __last,
                         __out_first, __rand,
                         __out_last - __out_first);
}



template <class _ForwardIter, class _Predicate>
_ForwardIter __partition(_ForwardIter __first,
                         _ForwardIter __last,
                         _Predicate __pred,
                         forward_iterator_tag)
{
  if (__first == __last) return __first;

  while (__pred(*__first))
    if (++__first == __last) return __first;

  _ForwardIter __next = __first;

  while (++__next != __last)
    if (__pred(*__next)) {
      swap(*__first, *__next);
      ++__first;
    }

  return __first;
}

template <class _BidirectionalIter, class _Predicate>
_BidirectionalIter __partition(_BidirectionalIter __first,
                               _BidirectionalIter __last,
                               _Predicate __pred,
                               bidirectional_iterator_tag)
{
  while (true) {
    while (true)
      if (__first == __last)
        return __first;
      else if (__pred(*__first))
        ++__first;
      else
        break;
    --__last;
    while (true)
      if (__first == __last)
        return __first;
      else if (!__pred(*__last))
        --__last;
      else
        break;
    iter_swap(__first, __last);
    ++__first;
  }
}

template <class _ForwardIter, class _Predicate>
inline _ForwardIter partition(_ForwardIter __first,
                              _ForwardIter __last,
                              _Predicate __pred)
{

                                                                            ;
                                                            ;


  return __partition(__first, __last, __pred, __iterator_category(__first));
}


template <class _ForwardIter, class _Predicate, class _Distance>
_ForwardIter __inplace_stable_partition(_ForwardIter __first,
                                        _ForwardIter __last,
                                        _Predicate __pred, _Distance __len)
{
  if (__len == 1)
    return __pred(*__first) ? __last : __first;
  _ForwardIter __middle = __first;
  advance(__middle, __len / 2);
  return rotate(__inplace_stable_partition(__first, __middle, __pred,
                                           __len / 2),
                __middle,
                __inplace_stable_partition(__middle, __last, __pred,
                                           __len - __len / 2));
}

template <class _ForwardIter, class _Pointer, class _Predicate,
          class _Distance>
_ForwardIter __stable_partition_adaptive(_ForwardIter __first,
                                         _ForwardIter __last,
                                         _Predicate __pred, _Distance __len,
                                         _Pointer __buffer,
                                         _Distance __buffer_size)
{
  if (__len <= __buffer_size) {
    _ForwardIter __result1 = __first;
    _Pointer __result2 = __buffer;
    for ( ; __first != __last ; ++__first)
      if (__pred(*__first)) {
        *__result1 = *__first;
        ++__result1;
      }
      else {
        *__result2 = *__first;
        ++__result2;
      }
    copy(__buffer, __result2, __result1);
    return __result1;
  }
  else {
    _ForwardIter __middle = __first;
    advance(__middle, __len / 2);
    return rotate(__stable_partition_adaptive(
                          __first, __middle, __pred,
                          __len / 2, __buffer, __buffer_size),
                    __middle,
                    __stable_partition_adaptive(
                          __middle, __last, __pred,
                          __len - __len / 2, __buffer, __buffer_size));
  }
}

template <class _ForwardIter, class _Predicate, class _Tp, class _Distance>
inline _ForwardIter
__stable_partition_aux(_ForwardIter __first, _ForwardIter __last,
                       _Predicate __pred, _Tp*, _Distance*)
{
  _Temporary_buffer<_ForwardIter, _Tp> __buf(__first, __last);
  if (__buf.size() > 0)
    return __stable_partition_adaptive(__first, __last, __pred,
                                       _Distance(__buf.requested_size()),
                                       __buf.begin(), __buf.size());
  else
    return __inplace_stable_partition(__first, __last, __pred,
                                      _Distance(__buf.requested_size()));
}

template <class _ForwardIter, class _Predicate>
inline _ForwardIter stable_partition(_ForwardIter __first,
                                     _ForwardIter __last,
                                     _Predicate __pred)
{

                                                                            ;
                                                            ;


  if (__first == __last)
    return __first;
  else
    return __stable_partition_aux(__first, __last, __pred,
                                  __value_type(__first),
                                  __distance_type(__first));
}

template <class _RandomAccessIter, class _Tp>
_RandomAccessIter __unguarded_partition(_RandomAccessIter __first,
                                        _RandomAccessIter __last,
                                        _Tp __pivot)
{
  while (true) {
    while (*__first < __pivot)
      ++__first;
    --__last;
    while (__pivot < *__last)
      --__last;
    if (!(__first < __last))
      return __first;
    iter_swap(__first, __last);
    ++__first;
  }
}

template <class _RandomAccessIter, class _Tp, class _Compare>
_RandomAccessIter __unguarded_partition(_RandomAccessIter __first,
                                        _RandomAccessIter __last,
                                        _Tp __pivot, _Compare __comp)
{
  while (true) {
    while (__comp(*__first, __pivot))
      ++__first;
    --__last;
    while (__comp(__pivot, *__last))
      --__last;
    if (!(__first < __last))
      return __first;
    iter_swap(__first, __last);
    ++__first;
  }
}

const int __stl_threshold = 16;



template <class _RandomAccessIter, class _Tp>
void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val)
{
  _RandomAccessIter __next = __last;
  --__next;
  while (__val < *__next) {
    *__last = *__next;
    __last = __next;
    --__next;
  }
  *__last = __val;
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val,
                               _Compare __comp)
{
  _RandomAccessIter __next = __last;
  --__next;
  while (__comp(__val, *__next)) {
    *__last = *__next;
    __last = __next;
    --__next;
  }
  *__last = __val;
}

template <class _RandomAccessIter, class _Tp>
inline void __linear_insert(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Tp*)
{
  _Tp __val = *__last;
  if (__val < *__first) {
    copy_backward(__first, __last, __last + 1);
    *__first = __val;
  }
  else
    __unguarded_linear_insert(__last, __val);
}

template <class _RandomAccessIter, class _Tp, class _Compare>
inline void __linear_insert(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Tp*, _Compare __comp)
{
  _Tp __val = *__last;
  if (__comp(__val, *__first)) {
    copy_backward(__first, __last, __last + 1);
    *__first = __val;
  }
  else
    __unguarded_linear_insert(__last, __val, __comp);
}

template <class _RandomAccessIter>
void __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last)
{
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    __linear_insert(__first, __i, __value_type(__first));
}

template <class _RandomAccessIter, class _Compare>
void __insertion_sort(_RandomAccessIter __first,
                      _RandomAccessIter __last, _Compare __comp)
{
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    __linear_insert(__first, __i, __value_type(__first), __comp);
}

template <class _RandomAccessIter, class _Tp>
void __unguarded_insertion_sort_aux(_RandomAccessIter __first,
                                    _RandomAccessIter __last, _Tp*)
{
  for (_RandomAccessIter __i = __first; __i != __last; ++__i)
    __unguarded_linear_insert(__i, _Tp(*__i));
}

template <class _RandomAccessIter>
inline void __unguarded_insertion_sort(_RandomAccessIter __first,
                                _RandomAccessIter __last) {
  __unguarded_insertion_sort_aux(__first, __last, __value_type(__first));
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __unguarded_insertion_sort_aux(_RandomAccessIter __first,
                                    _RandomAccessIter __last,
                                    _Tp*, _Compare __comp)
{
  for (_RandomAccessIter __i = __first; __i != __last; ++__i)
    __unguarded_linear_insert(__i, _Tp(*__i), __comp);
}

template <class _RandomAccessIter, class _Compare>
inline void __unguarded_insertion_sort(_RandomAccessIter __first,
                                       _RandomAccessIter __last,
                                       _Compare __comp)
{
  __unguarded_insertion_sort_aux(__first, __last, __value_type(__first),
                                 __comp);
}

template <class _RandomAccessIter>
void __final_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last)
{
  if (__last - __first > __stl_threshold) {
    __insertion_sort(__first, __first + __stl_threshold);
    __unguarded_insertion_sort(__first + __stl_threshold, __last);
  }
  else
    __insertion_sort(__first, __last);
}

template <class _RandomAccessIter, class _Compare>
void __final_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Compare __comp)
{
  if (__last - __first > __stl_threshold) {
    __insertion_sort(__first, __first + __stl_threshold, __comp);
    __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp);
  }
  else
    __insertion_sort(__first, __last, __comp);
}

template <class _Size>
inline _Size __lg(_Size __n)
{
  _Size __k;
  for (__k = 0; __n != 1; __n >>= 1) ++__k;
  return __k;
}

template <class _RandomAccessIter, class _Tp, class _Size>
void __introsort_loop(_RandomAccessIter __first,
                      _RandomAccessIter __last, _Tp*,
                      _Size __depth_limit)
{
  while (__last - __first > __stl_threshold) {
    if (__depth_limit == 0) {
      partial_sort(__first, __last, __last);
      return;
    }
    --__depth_limit;
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1))));
    __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit);
    __last = __cut;
  }
}

template <class _RandomAccessIter, class _Tp, class _Size, class _Compare>
void __introsort_loop(_RandomAccessIter __first,
                      _RandomAccessIter __last, _Tp*,
                      _Size __depth_limit, _Compare __comp)
{
  while (__last - __first > __stl_threshold) {
    if (__depth_limit == 0) {
      partial_sort(__first, __last, __last, __comp);
      return;
    }
    --__depth_limit;
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1), __comp)),
       __comp);
    __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit, __comp);
    __last = __cut;
  }
}

template <class _RandomAccessIter>
inline void sort(_RandomAccessIter __first, _RandomAccessIter __last)
{

                           ;

                                                                 ;


  if (__first != __last) {
    __introsort_loop(__first, __last,
                     __value_type(__first),
                     __lg(__last - __first) * 2);
    __final_insertion_sort(__first, __last);
  }
}

template <class _RandomAccessIter, class _Compare>
inline void sort(_RandomAccessIter __first, _RandomAccessIter __last,
                 _Compare __comp)
{

                           ;

                                                                 ;



  if (__first != __last) {
    __introsort_loop(__first, __last,
                     __value_type(__first),
                     __lg(__last - __first) * 2,
                     __comp);
    __final_insertion_sort(__first, __last, __comp);
  }
}



template <class _RandomAccessIter>
void __inplace_stable_sort(_RandomAccessIter __first,
                           _RandomAccessIter __last)
{
  if (__last - __first < 15) {
    __insertion_sort(__first, __last);
    return;
  }
  _RandomAccessIter __middle = __first + (__last - __first) / 2;
  __inplace_stable_sort(__first, __middle);
  __inplace_stable_sort(__middle, __last);
  __merge_without_buffer(__first, __middle, __last,
                         __middle - __first,
                         __last - __middle);
}

template <class _RandomAccessIter, class _Compare>
void __inplace_stable_sort(_RandomAccessIter __first,
                           _RandomAccessIter __last, _Compare __comp)
{
  if (__last - __first < 15) {
    __insertion_sort(__first, __last, __comp);
    return;
  }
  _RandomAccessIter __middle = __first + (__last - __first) / 2;
  __inplace_stable_sort(__first, __middle, __comp);
  __inplace_stable_sort(__middle, __last, __comp);
  __merge_without_buffer(__first, __middle, __last,
                         __middle - __first,
                         __last - __middle,
                         __comp);
}

template <class _RandomAccessIter1, class _RandomAccessIter2,
          class _Distance>
void __merge_sort_loop(_RandomAccessIter1 __first,
                       _RandomAccessIter1 __last,
                       _RandomAccessIter2 __result, _Distance __step_size)
{
  _Distance __two_step = 2 * __step_size;

  while (__last - __first >= __two_step) {
    __result = merge(__first, __first + __step_size,
                     __first + __step_size, __first + __two_step,
                     __result);
    __first += __two_step;
  }

  __step_size = min(_Distance(__last - __first), __step_size);
  merge(__first, __first + __step_size, __first + __step_size, __last,
        __result);
}

template <class _RandomAccessIter1, class _RandomAccessIter2,
          class _Distance, class _Compare>
void __merge_sort_loop(_RandomAccessIter1 __first,
                       _RandomAccessIter1 __last,
                       _RandomAccessIter2 __result, _Distance __step_size,
                       _Compare __comp)
{
  _Distance __two_step = 2 * __step_size;

  while (__last - __first >= __two_step) {
    __result = merge(__first, __first + __step_size,
                     __first + __step_size, __first + __two_step,
                     __result,
                     __comp);
    __first += __two_step;
  }
  __step_size = min(_Distance(__last - __first), __step_size);

  merge(__first, __first + __step_size,
        __first + __step_size, __last,
        __result,
        __comp);
}

const int __stl_chunk_size = 7;

template <class _RandomAccessIter, class _Distance>
void __chunk_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Distance __chunk_size)
{
  while (__last - __first >= __chunk_size) {
    __insertion_sort(__first, __first + __chunk_size);
    __first += __chunk_size;
  }
  __insertion_sort(__first, __last);
}

template <class _RandomAccessIter, class _Distance, class _Compare>
void __chunk_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last,
                            _Distance __chunk_size, _Compare __comp)
{
  while (__last - __first >= __chunk_size) {
    __insertion_sort(__first, __first + __chunk_size, __comp);
    __first += __chunk_size;
  }
  __insertion_sort(__first, __last, __comp);
}

template <class _RandomAccessIter, class _Pointer, class _Distance>
void __merge_sort_with_buffer(_RandomAccessIter __first,
                              _RandomAccessIter __last,
                              _Pointer __buffer, _Distance*)
{
  _Distance __len = __last - __first;
  _Pointer __buffer_last = __buffer + __len;

  _Distance __step_size = __stl_chunk_size;
  __chunk_insertion_sort(__first, __last, __step_size);

  while (__step_size < __len) {
    __merge_sort_loop(__first, __last, __buffer, __step_size);
    __step_size *= 2;
    __merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
    __step_size *= 2;
  }
}

template <class _RandomAccessIter, class _Pointer, class _Distance,
          class _Compare>
void __merge_sort_with_buffer(_RandomAccessIter __first,
                              _RandomAccessIter __last, _Pointer __buffer,
                              _Distance*, _Compare __comp)
{
  _Distance __len = __last - __first;
  _Pointer __buffer_last = __buffer + __len;

  _Distance __step_size = __stl_chunk_size;
  __chunk_insertion_sort(__first, __last, __step_size, __comp);

  while (__step_size < __len) {
    __merge_sort_loop(__first, __last, __buffer, __step_size, __comp);
    __step_size *= 2;
    __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
    __step_size *= 2;
  }
}

template <class _RandomAccessIter, class _Pointer, class _Distance>
void __stable_sort_adaptive(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Pointer __buffer,
                            _Distance __buffer_size)
{
  _Distance __len = (__last - __first + 1) / 2;
  _RandomAccessIter __middle = __first + __len;
  if (__len > __buffer_size) {
    __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
    __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
  }
  else {
    __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0);
    __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0);
  }
  __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
                   _Distance(__last - __middle), __buffer, __buffer_size);
}

template <class _RandomAccessIter, class _Pointer, class _Distance,
          class _Compare>
void __stable_sort_adaptive(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Pointer __buffer,
                            _Distance __buffer_size, _Compare __comp)
{
  _Distance __len = (__last - __first + 1) / 2;
  _RandomAccessIter __middle = __first + __len;
  if (__len > __buffer_size) {
    __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size,
                           __comp);
    __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size,
                           __comp);
  }
  else {
    __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0,
                               __comp);
    __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0,
                               __comp);
  }
  __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
                   _Distance(__last - __middle), __buffer, __buffer_size,
                   __comp);
}

template <class _RandomAccessIter, class _Tp, class _Distance>
inline void __stable_sort_aux(_RandomAccessIter __first,
                              _RandomAccessIter __last, _Tp*, _Distance*)
{
  _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
  if (buf.begin() == 0)
    __inplace_stable_sort(__first, __last);
  else
    __stable_sort_adaptive(__first, __last, buf.begin(),
                           _Distance(buf.size()));
}

template <class _RandomAccessIter, class _Tp, class _Distance, class _Compare>
inline void __stable_sort_aux(_RandomAccessIter __first,
                              _RandomAccessIter __last, _Tp*, _Distance*,
                              _Compare __comp)
{
  _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
  if (buf.begin() == 0)
    __inplace_stable_sort(__first, __last, __comp);
  else
    __stable_sort_adaptive(__first, __last, buf.begin(),
                           _Distance(buf.size()),
                           __comp);
}

template <class _RandomAccessIter>
inline void stable_sort(_RandomAccessIter __first,
                        _RandomAccessIter __last)
{

                           ;

                                                                 ;


  __stable_sort_aux(__first, __last,
                    __value_type(__first),
                    __distance_type(__first));
}

template <class _RandomAccessIter, class _Compare>
inline void stable_sort(_RandomAccessIter __first,
                        _RandomAccessIter __last, _Compare __comp)
{

                           ;

                                                                 ;



  __stable_sort_aux(__first, __last,
                    __value_type(__first),
                    __distance_type(__first),
                    __comp);
}



template <class _RandomAccessIter, class _Tp>
void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
                    _RandomAccessIter __last, _Tp*)
{
  make_heap(__first, __middle);
  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
    if (*__i < *__first)
      __pop_heap(__first, __middle, __i, _Tp(*__i),
                 __distance_type(__first));
  sort_heap(__first, __middle);
}

template <class _RandomAccessIter>
inline void partial_sort(_RandomAccessIter __first,
                         _RandomAccessIter __middle,
                         _RandomAccessIter __last)
{

                           ;

                                                                 ;


  __partial_sort(__first, __middle, __last, __value_type(__first));
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
                    _RandomAccessIter __last, _Tp*, _Compare __comp)
{
  make_heap(__first, __middle, __comp);
  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
    if (__comp(*__i, *__first))
      __pop_heap(__first, __middle, __i, _Tp(*__i), __comp,
                 __distance_type(__first));
  sort_heap(__first, __middle, __comp);
}

template <class _RandomAccessIter, class _Compare>
inline void partial_sort(_RandomAccessIter __first,
                         _RandomAccessIter __middle,
                         _RandomAccessIter __last, _Compare __comp)
{

                           ;

                                                                 ;



  __partial_sort(__first, __middle, __last, __value_type(__first), __comp);
}

template <class _InputIter, class _RandomAccessIter, class _Distance,
          class _Tp>
_RandomAccessIter __partial_sort_copy(_InputIter __first,
                                      _InputIter __last,
                                      _RandomAccessIter __result_first,
                                      _RandomAccessIter __result_last,
                                      _Distance*, _Tp*)
{
  if (__result_first == __result_last) return __result_last;
  _RandomAccessIter __result_real_last = __result_first;
  while(__first != __last && __result_real_last != __result_last) {
    *__result_real_last = *__first;
    ++__result_real_last;
    ++__first;
  }
  make_heap(__result_first, __result_real_last);
  while (__first != __last) {
    if (*__first < *__result_first)
      __adjust_heap(__result_first, _Distance(0),
                    _Distance(__result_real_last - __result_first),
                    _Tp(*__first));
    ++__first;
  }
  sort_heap(__result_first, __result_real_last);
  return __result_real_last;
}

template <class _InputIter, class _RandomAccessIter>
inline _RandomAccessIter
partial_sort_copy(_InputIter __first, _InputIter __last,
                  _RandomAccessIter __result_first,
                  _RandomAccessIter __result_last)
{

                                                                ;
                                                                 ;


                                                                 ;

                                                          ;


  return __partial_sort_copy(__first, __last, __result_first, __result_last,
                             __distance_type(__result_first),
                             __value_type(__first));
}

template <class _InputIter, class _RandomAccessIter, class _Compare,
          class _Distance, class _Tp>
_RandomAccessIter __partial_sort_copy(_InputIter __first,
                                         _InputIter __last,
                                         _RandomAccessIter __result_first,
                                         _RandomAccessIter __result_last,
                                         _Compare __comp, _Distance*, _Tp*)
{
  if (__result_first == __result_last) return __result_last;
  _RandomAccessIter __result_real_last = __result_first;
  while(__first != __last && __result_real_last != __result_last) {
    *__result_real_last = *__first;
    ++__result_real_last;
    ++__first;
  }
  make_heap(__result_first, __result_real_last, __comp);
  while (__first != __last) {
    if (__comp(*__first, *__result_first))
      __adjust_heap(__result_first, _Distance(0),
                    _Distance(__result_real_last - __result_first),
                    _Tp(*__first),
                    __comp);
    ++__first;
  }
  sort_heap(__result_first, __result_real_last, __comp);
  return __result_real_last;
}

template <class _InputIter, class _RandomAccessIter, class _Compare>
inline _RandomAccessIter
partial_sort_copy(_InputIter __first, _InputIter __last,
                  _RandomAccessIter __result_first,
                  _RandomAccessIter __result_last, _Compare __comp)
{

                                                                ;
                           ;

                                                                 ;


                                                                 ;



  return __partial_sort_copy(__first, __last, __result_first, __result_last,
                             __comp,
                             __distance_type(__result_first),
                             __value_type(__first));
}



template <class _RandomAccessIter, class _Tp>
void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                   _RandomAccessIter __last, _Tp*)
{
  while (__last - __first > 3) {
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1))));
    if (__cut <= __nth)
      __first = __cut;
    else
      __last = __cut;
  }
  __insertion_sort(__first, __last);
}

template <class _RandomAccessIter>
inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                        _RandomAccessIter __last)
{

                           ;

                                                                 ;


  __nth_element(__first, __nth, __last, __value_type(__first));
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                   _RandomAccessIter __last, _Tp*, _Compare __comp)
{
  while (__last - __first > 3) {
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1),
                                         __comp)),
                            __comp);
    if (__cut <= __nth)
      __first = __cut;
    else
      __last = __cut;
  }
  __insertion_sort(__first, __last, __comp);
}

template <class _RandomAccessIter, class _Compare>
inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                        _RandomAccessIter __last, _Compare __comp)
{

                           ;

                                                                 ;



  __nth_element(__first, __nth, __last, __value_type(__first), __comp);
}




template <class _ForwardIter, class _Tp, class _Distance>
_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
                           const _Tp& __val, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (*__middle < __val) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else
      __len = __half;
  }
  return __first;
}

template <class _ForwardIter, class _Tp>
inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val)
{

                                                                    ;
                                                            ;

                                                              ;

  return __lower_bound(__first, __last, __val,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
                              const _Tp& __val, _Compare __comp, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__comp(*__middle, __val)) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else
      __len = __half;
  }
  return __first;
}

template <class _ForwardIter, class _Tp, class _Compare>
inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val, _Compare __comp)
{

                                                                    ;
                                                            ;

                                                                          ;

  return __lower_bound(__first, __last, __val, __comp,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Distance>
_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
                           const _Tp& __val, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__val < *__middle)
      __len = __half;
    else {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
  }
  return __first;
}

template <class _ForwardIter, class _Tp>
inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val)
{

                                                                    ;
                                                            ;

                                                              ;

  return __upper_bound(__first, __last, __val,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
                           const _Tp& __val, _Compare __comp, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__comp(__val, *__middle))
      __len = __half;
    else {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
  }
  return __first;
}

template <class _ForwardIter, class _Tp, class _Compare>
inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val, _Compare __comp)
{

                                                                    ;
                                                            ;

                                                                          ;

  return __upper_bound(__first, __last, __val, __comp,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Distance>
pair<_ForwardIter, _ForwardIter>
__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
              _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle, __left, __right;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (*__middle < __val) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else if (__val < *__middle)
      __len = __half;
    else {
      __left = lower_bound(__first, __middle, __val);
      advance(__first, __len);
      __right = upper_bound(++__middle, __first, __val);
      return pair<_ForwardIter, _ForwardIter>(__left, __right);
    }
  }
  return pair<_ForwardIter, _ForwardIter>(__first, __first);
}

template <class _ForwardIter, class _Tp>
inline pair<_ForwardIter, _ForwardIter>
equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
{

                                                                    ;
                                                            ;

                                                              ;

  return __equal_range(__first, __last, __val,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
pair<_ForwardIter, _ForwardIter>
__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
              _Compare __comp, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle, __left, __right;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__comp(*__middle, __val)) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else if (__comp(__val, *__middle))
      __len = __half;
    else {
      __left = lower_bound(__first, __middle, __val, __comp);
      advance(__first, __len);
      __right = upper_bound(++__middle, __first, __val, __comp);
      return pair<_ForwardIter, _ForwardIter>(__left, __right);
    }
  }
  return pair<_ForwardIter, _ForwardIter>(__first, __first);
}

template <class _ForwardIter, class _Tp, class _Compare>
inline pair<_ForwardIter, _ForwardIter>
equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
            _Compare __comp)
{

                                                                    ;
                                                            ;

                                                                          ;

  return __equal_range(__first, __last, __val, __comp,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp>
bool binary_search(_ForwardIter __first, _ForwardIter __last,
                   const _Tp& __val)
{

                                                                    ;
                                                            ;

                                                              ;

  _ForwardIter __i = lower_bound(__first, __last, __val);
  return __i != __last && !(__val < *__i);
}

template <class _ForwardIter, class _Tp, class _Compare>
bool binary_search(_ForwardIter __first, _ForwardIter __last,
                   const _Tp& __val,
                   _Compare __comp)
{

                                                                    ;
                                                            ;

                                                                          ;

  _ForwardIter __i = lower_bound(__first, __last, __val, __comp);
  return __i != __last && !__comp(__val, *__i);
}



template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2, _InputIter2 __last2,
                  _OutputIter __result)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


                                                           ;


  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2, _InputIter2 __last2,
                  _OutputIter __result, _Compare __comp)
{

                                                                 ;
                                                                 ;
                                                           ;


                                                           ;

                                                           ;



  while (__first1 != __last1 && __first2 != __last2) {
    if (__comp(*__first2, *__first1)) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}



template <class _BidirectionalIter, class _Distance>
void __merge_without_buffer(_BidirectionalIter __first,
                            _BidirectionalIter __middle,
                            _BidirectionalIter __last,
                            _Distance __len1, _Distance __len2)
{
  if (__len1 == 0 || __len2 == 0)
    return;
  if (__len1 + __len2 == 2) {
    if (*__middle < *__first)
      iter_swap(__first, __middle);
    return;
  }
  _BidirectionalIter __first_cut = __first;
  _BidirectionalIter __second_cut = __middle;
  _Distance __len11 = 0;
  _Distance __len22 = 0;
  if (__len1 > __len2) {
    __len11 = __len1 / 2;
    advance(__first_cut, __len11);
    __second_cut = lower_bound(__middle, __last, *__first_cut);
    distance(__middle, __second_cut, __len22);
  }
  else {
    __len22 = __len2 / 2;
    advance(__second_cut, __len22);
    __first_cut = upper_bound(__first, __middle, *__second_cut);
    distance(__first, __first_cut, __len11);
  }
  _BidirectionalIter __new_middle
    = rotate(__first_cut, __middle, __second_cut);
  __merge_without_buffer(__first, __first_cut, __new_middle,
                         __len11, __len22);
  __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
                         __len2 - __len22);
}

template <class _BidirectionalIter, class _Distance, class _Compare>
void __merge_without_buffer(_BidirectionalIter __first,
                            _BidirectionalIter __middle,
                            _BidirectionalIter __last,
                            _Distance __len1, _Distance __len2,
                            _Compare __comp)
{
  if (__len1 == 0 || __len2 == 0)
    return;
  if (__len1 + __len2 == 2) {
    if (__comp(*__middle, *__first))
      iter_swap(__first, __middle);
    return;
  }
  _BidirectionalIter __first_cut = __first;
  _BidirectionalIter __second_cut = __middle;
  _Distance __len11 = 0;
  _Distance __len22 = 0;
  if (__len1 > __len2) {
    __len11 = __len1 / 2;
    advance(__first_cut, __len11);
    __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
    distance(__middle, __second_cut, __len22);
  }
  else {
    __len22 = __len2 / 2;
    advance(__second_cut, __len22);
    __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
    distance(__first, __first_cut, __len11);
  }
  _BidirectionalIter __new_middle
    = rotate(__first_cut, __middle, __second_cut);
  __merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22,
                         __comp);
  __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
                         __len2 - __len22, __comp);
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _Distance>
_BidirectionalIter1 __rotate_adaptive(_BidirectionalIter1 __first,
                                      _BidirectionalIter1 __middle,
                                      _BidirectionalIter1 __last,
                                      _Distance __len1, _Distance __len2,
                                      _BidirectionalIter2 __buffer,
                                      _Distance __buffer_size)
{
  _BidirectionalIter2 __buffer_end;
  if (__len1 > __len2 && __len2 <= __buffer_size) {
    __buffer_end = copy(__middle, __last, __buffer);
    copy_backward(__first, __middle, __last);
    return copy(__buffer, __buffer_end, __first);
  }
  else if (__len1 <= __buffer_size) {
    __buffer_end = copy(__first, __middle, __buffer);
    copy(__middle, __last, __first);
    return copy_backward(__buffer, __buffer_end, __last);
  }
  else
    return rotate(__first, __middle, __last);
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BidirectionalIter3>
_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
                                     _BidirectionalIter1 __last1,
                                     _BidirectionalIter2 __first2,
                                     _BidirectionalIter2 __last2,
                                     _BidirectionalIter3 __result)
{
  if (__first1 == __last1)
    return copy_backward(__first2, __last2, __result);
  if (__first2 == __last2)
    return copy_backward(__first1, __last1, __result);
  --__last1;
  --__last2;
  while (true) {
    if (*__last2 < *__last1) {
      *--__result = *__last1;
      if (__first1 == __last1)
        return copy_backward(__first2, ++__last2, __result);
      --__last1;
    }
    else {
      *--__result = *__last2;
      if (__first2 == __last2)
        return copy_backward(__first1, ++__last1, __result);
      --__last2;
    }
  }
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BidirectionalIter3, class _Compare>
_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
                                     _BidirectionalIter1 __last1,
                                     _BidirectionalIter2 __first2,
                                     _BidirectionalIter2 __last2,
                                     _BidirectionalIter3 __result,
                                     _Compare __comp)
{
  if (__first1 == __last1)
    return copy_backward(__first2, __last2, __result);
  if (__first2 == __last2)
    return copy_backward(__first1, __last1, __result);
  --__last1;
  --__last2;
  while (true) {
    if (__comp(*__last2, *__last1)) {
      *--__result = *__last1;
      if (__first1 == __last1)
        return copy_backward(__first2, ++__last2, __result);
      --__last1;
    }
    else {
      *--__result = *__last2;
      if (__first2 == __last2)
        return copy_backward(__first1, ++__last1, __result);
      --__last2;
    }
  }
}

template <class _BidirectionalIter, class _Distance, class _Pointer>
void __merge_adaptive(_BidirectionalIter __first,
                      _BidirectionalIter __middle,
                      _BidirectionalIter __last,
                      _Distance __len1, _Distance __len2,
                      _Pointer __buffer, _Distance __buffer_size)
{
  if (__len1 <= __len2 && __len1 <= __buffer_size) {
    _Pointer __buffer_end = copy(__first, __middle, __buffer);
    merge(__buffer, __buffer_end, __middle, __last, __first);
  }
  else if (__len2 <= __buffer_size) {
    _Pointer __buffer_end = copy(__middle, __last, __buffer);
    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);
  }
  else {
    _BidirectionalIter __first_cut = __first;
    _BidirectionalIter __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2) {
      __len11 = __len1 / 2;
      advance(__first_cut, __len11);
      __second_cut = lower_bound(__middle, __last, *__first_cut);
      distance(__middle, __second_cut, __len22);
    }
    else {
      __len22 = __len2 / 2;
      advance(__second_cut, __len22);
      __first_cut = upper_bound(__first, __middle, *__second_cut);
      distance(__first, __first_cut, __len11);
    }
    _BidirectionalIter __new_middle =
      __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
                        __len22, __buffer, __buffer_size);
    __merge_adaptive(__first, __first_cut, __new_middle, __len11,
                     __len22, __buffer, __buffer_size);
    __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
                     __len2 - __len22, __buffer, __buffer_size);
  }
}

template <class _BidirectionalIter, class _Distance, class _Pointer,
          class _Compare>
void __merge_adaptive(_BidirectionalIter __first,
                      _BidirectionalIter __middle,
                      _BidirectionalIter __last,
                      _Distance __len1, _Distance __len2,
                      _Pointer __buffer, _Distance __buffer_size,
                      _Compare __comp)
{
  if (__len1 <= __len2 && __len1 <= __buffer_size) {
    _Pointer __buffer_end = copy(__first, __middle, __buffer);
    merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
  }
  else if (__len2 <= __buffer_size) {
    _Pointer __buffer_end = copy(__middle, __last, __buffer);
    __merge_backward(__first, __middle, __buffer, __buffer_end, __last,
                     __comp);
  }
  else {
    _BidirectionalIter __first_cut = __first;
    _BidirectionalIter __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2) {
      __len11 = __len1 / 2;
      advance(__first_cut, __len11);
      __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
      distance(__middle, __second_cut, __len22);
    }
    else {
      __len22 = __len2 / 2;
      advance(__second_cut, __len22);
      __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
      distance(__first, __first_cut, __len11);
    }
    _BidirectionalIter __new_middle =
      __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
                        __len22, __buffer, __buffer_size);
    __merge_adaptive(__first, __first_cut, __new_middle, __len11,
                     __len22, __buffer, __buffer_size, __comp);
    __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
                     __len2 - __len22, __buffer, __buffer_size, __comp);
  }
}

template <class _BidirectionalIter, class _Tp, class _Distance>
inline void __inplace_merge_aux(_BidirectionalIter __first,
                                _BidirectionalIter __middle,
                                _BidirectionalIter __last, _Tp*, _Distance*)
{
  _Distance __len1 = 0;
  distance(__first, __middle, __len1);
  _Distance __len2 = 0;
  distance(__middle, __last, __len2);

  _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
  if (__buf.begin() == 0)
    __merge_without_buffer(__first, __middle, __last, __len1, __len2);
  else
    __merge_adaptive(__first, __middle, __last, __len1, __len2,
                     __buf.begin(), _Distance(__buf.size()));
}

template <class _BidirectionalIter, class _Tp,
          class _Distance, class _Compare>
inline void __inplace_merge_aux(_BidirectionalIter __first,
                                _BidirectionalIter __middle,
                                _BidirectionalIter __last, _Tp*, _Distance*,
                                _Compare __comp)
{
  _Distance __len1 = 0;
  distance(__first, __middle, __len1);
  _Distance __len2 = 0;
  distance(__middle, __last, __len2);

  _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
  if (__buf.begin() == 0)
    __merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
  else
    __merge_adaptive(__first, __middle, __last, __len1, __len2,
                     __buf.begin(), _Distance(__buf.size()),
                     __comp);
}

template <class _BidirectionalIter>
inline void inplace_merge(_BidirectionalIter __first,
                          _BidirectionalIter __middle,
                          _BidirectionalIter __last)
{

                            ;

                                                                  ;


  if (__first == __middle || __middle == __last)
    return;
  __inplace_merge_aux(__first, __middle, __last,
                      __value_type(__first), __distance_type(__first));
}

template <class _BidirectionalIter, class _Compare>
inline void inplace_merge(_BidirectionalIter __first,
                          _BidirectionalIter __middle,
                          _BidirectionalIter __last, _Compare __comp)
{

                            ;

                                                                  ;



  if (__first == __middle || __middle == __last)
    return;
  __inplace_merge_aux(__first, __middle, __last,
                      __value_type(__first), __distance_type(__first),
                      __comp);
}






template <class _InputIter1, class _InputIter2>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2)
{

                                                                 ;
                                                                 ;
                                                           ;


                                                           ;


  while (__first1 != __last1 && __first2 != __last2)
    if (*__first2 < *__first1)
      return false;
    else if(*__first1 < *__first2)
      ++__first1;
    else
      ++__first1, ++__first2;

  return __first2 == __last2;
}

template <class _InputIter1, class _InputIter2, class _Compare>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
{

                                                                 ;
                                                                 ;
                                                           ;


                                                           ;



  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first2, *__first1))
      return false;
    else if(__comp(*__first1, *__first2))
      ++__first1;
    else
      ++__first1, ++__first2;

  return __first2 == __last2;
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
                      _InputIter2 __first2, _InputIter2 __last2,
                      _OutputIter __result)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


                                                           ;


  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first1 < *__first2) {
      *__result = *__first1;
      ++__first1;
    }
    else if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
                      _InputIter2 __first2, _InputIter2 __last2,
                      _OutputIter __result, _Compare __comp)
{

                                                                 ;
                                                                 ;
                                                           ;


                                                           ;

                                                           ;



  while (__first1 != __last1 && __first2 != __last2) {
    if (__comp(*__first1, *__first2)) {
      *__result = *__first1;
      ++__first1;
    }
    else if (__comp(*__first2, *__first1)) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _OutputIter __result)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


                                                           ;


  while (__first1 != __last1 && __first2 != __last2)
    if (*__first1 < *__first2)
      ++__first1;
    else if (*__first2 < *__first1)
      ++__first2;
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
      ++__result;
    }
  return __result;
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _OutputIter __result, _Compare __comp)
{

                                                                 ;
                                                                 ;
                                                           ;


                                                           ;

                                                           ;



  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first1, *__first2))
      ++__first1;
    else if (__comp(*__first2, *__first1))
      ++__first2;
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
      ++__result;
    }
  return __result;
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
                           _InputIter2 __first2, _InputIter2 __last2,
                           _OutputIter __result)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


                                                           ;


  while (__first1 != __last1 && __first2 != __last2)
    if (*__first1 < *__first2) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (*__first2 < *__first1)
      ++__first2;
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first1, __last1, __result);
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
                           _InputIter2 __first2, _InputIter2 __last2,
                           _OutputIter __result, _Compare __comp)
{

                                                                 ;
                                                                 ;
                                                           ;


                                                           ;

                                                           ;



  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first1, *__first2)) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (__comp(*__first2, *__first1))
      ++__first2;
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first1, __last1, __result);
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter
set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
                         _InputIter2 __first2, _InputIter2 __last2,
                         _OutputIter __result)
{

                                                                 ;
                                                                 ;
                                                           ;

                                                           ;


                                                           ;


  while (__first1 != __last1 && __first2 != __last2)
    if (*__first1 < *__first2) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
      ++__result;
    }
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter
set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
                         _InputIter2 __first2, _InputIter2 __last2,
                         _OutputIter __result,
                         _Compare __comp)
{

                                                                 ;
                                                                 ;
                                                           ;


                                                           ;

                                                           ;



  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first1, *__first2)) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (__comp(*__first2, *__first1)) {
      *__result = *__first2;
      ++__first2;
      ++__result;
    }
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}




template <class _ForwardIter>
_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last)
{

                                                                    ;
                                                            ;


  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (*__result < *__first)
      __result = __first;
  return __result;
}

template <class _ForwardIter, class _Compare>
_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
                         _Compare __comp)
{

                                                                    ;
                                                            ;



  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (__comp(*__result, *__first)) __result = __first;
  return __result;
}

template <class _ForwardIter>
_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last)
{

                                                                    ;
                                                            ;


  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (*__first < *__result)
      __result = __first;
  return __result;
}

template <class _ForwardIter, class _Compare>
_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
                         _Compare __comp)
{

                                                                    ;
                                                            ;



  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (__comp(*__first, *__result))
      __result = __first;
  return __result;
}




template <class _BidirectionalIter>
bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
{

                                                                                ;
                                                                  ;


  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (*__i < *__ii) {
      _BidirectionalIter __j = __last;
      while (!(*__i < *--__j))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}

template <class _BidirectionalIter, class _Compare>
bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
                      _Compare __comp)
{

                                                                                ;
                                                                  ;



  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (__comp(*__i, *__ii)) {
      _BidirectionalIter __j = __last;
      while (!__comp(*__i, *--__j))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}

template <class _BidirectionalIter>
bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
{

                                                                                ;
                                                                  ;


  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (*__ii < *__i) {
      _BidirectionalIter __j = __last;
      while (!(*--__j < *__i))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}

template <class _BidirectionalIter, class _Compare>
bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
                      _Compare __comp)
{

                                                                                ;
                                                                  ;



  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (__comp(*__ii, *__i)) {
      _BidirectionalIter __j = __last;
      while (!__comp(*--__j, *__i))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}



template <class _InputIter, class _ForwardIter>
_InputIter find_first_of(_InputIter __first1, _InputIter __last1,
                         _ForwardIter __first2, _ForwardIter __last2)
{

                                                                ;
                                                                    ;
                                                            ;



  for ( ; __first1 != __last1; ++__first1)
    for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
      if (*__first1 == *__iter)
        return __first1;
  return __last1;
}

template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
_InputIter find_first_of(_InputIter __first1, _InputIter __last1,
                         _ForwardIter __first2, _ForwardIter __last2,
                         _BinaryPredicate __comp)
{

                                                                ;
                                                                    ;
                                                            ;


                                                            ;



  for ( ; __first1 != __last1; ++__first1)
    for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
      if (__comp(*__first1, *__iter))
        return __first1;
  return __last1;
}
# 3419 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_algo.h" 3
template <class _ForwardIter1, class _ForwardIter2>
_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
                         _ForwardIter2 __first2, _ForwardIter2 __last2,
                         forward_iterator_tag, forward_iterator_tag)
{
  if (__first2 == __last2)
    return __last1;
  else {
    _ForwardIter1 __result = __last1;
    while (1) {
      _ForwardIter1 __new_result
        = search(__first1, __last1, __first2, __last2);
      if (__new_result == __last1)
        return __result;
      else {
        __result = __new_result;
        __first1 = __new_result;
        ++__first1;
      }
    }
  }
}

template <class _ForwardIter1, class _ForwardIter2,
          class _BinaryPredicate>
_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
                         _ForwardIter2 __first2, _ForwardIter2 __last2,
                         forward_iterator_tag, forward_iterator_tag,
                         _BinaryPredicate __comp)
{
  if (__first2 == __last2)
    return __last1;
  else {
    _ForwardIter1 __result = __last1;
    while (1) {
      _ForwardIter1 __new_result
        = search(__first1, __last1, __first2, __last2, __comp);
      if (__new_result == __last1)
        return __result;
      else {
        __result = __new_result;
        __first1 = __new_result;
        ++__first1;
      }
    }
  }
}


template <class _BidirectionalIter1, class _BidirectionalIter2>
_BidirectionalIter1
__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
           _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
           bidirectional_iterator_tag, bidirectional_iterator_tag)
{

                                                                                 ;
                                                                                 ;

  typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
  typedef reverse_iterator<_BidirectionalIter2> _RevIter2;

  _RevIter1 __rlast1(__first1);
  _RevIter2 __rlast2(__first2);
  _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
                               _RevIter2(__last2), __rlast2);

  if (__rresult == __rlast1)
    return __last1;
  else {
    _BidirectionalIter1 __result = __rresult.base();
    advance(__result, -distance(__first2, __last2));
    return __result;
  }
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BinaryPredicate>
_BidirectionalIter1
__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
           _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
           bidirectional_iterator_tag, bidirectional_iterator_tag,
           _BinaryPredicate __comp)
{

                                                                                 ;
                                                                                 ;

  typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
  typedef reverse_iterator<_BidirectionalIter2> _RevIter2;

  _RevIter1 __rlast1(__first1);
  _RevIter2 __rlast2(__first2);
  _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
                               _RevIter2(__last2), __rlast2,
                               __comp);

  if (__rresult == __rlast1)
    return __last1;
  else {
    _BidirectionalIter1 __result = __rresult.base();
    advance(__result, -distance(__first2, __last2));
    return __result;
  }
}



template <class _ForwardIter1, class _ForwardIter2>
inline _ForwardIter1
find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
         _ForwardIter2 __first2, _ForwardIter2 __last2)
{

                                                                     ;
                                                                     ;
                                                             ;



  return __find_end(__first1, __last1, __first2, __last2,
                    __iterator_category(__first1),
                    __iterator_category(__first2));
}

template <class _ForwardIter1, class _ForwardIter2,
          class _BinaryPredicate>
inline _ForwardIter1
find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
         _ForwardIter2 __first2, _ForwardIter2 __last2,
         _BinaryPredicate __comp)
{

                                                                     ;
                                                                     ;
                                                             ;



  return __find_end(__first1, __last1, __first2, __last2,
                    __iterator_category(__first1),
                    __iterator_category(__first2),
                    __comp);
}





template <class _RandomAccessIter, class _Distance>
bool __is_heap(_RandomAccessIter __first, _Distance __n)
{
  _Distance __parent = 0;
  for (_Distance __child = 1; __child < __n; ++__child) {
    if (__first[__parent] < __first[__child])
      return false;
    if ((__child & 1) == 0)
      ++__parent;
  }
  return true;
}

template <class _RandomAccessIter, class _Distance, class _StrictWeakOrdering>
bool __is_heap(_RandomAccessIter __first, _StrictWeakOrdering __comp,
               _Distance __n)
{
  _Distance __parent = 0;
  for (_Distance __child = 1; __child < __n; ++__child) {
    if (__comp(__first[__parent], __first[__child]))
      return false;
    if ((__child & 1) == 0)
      ++__parent;
  }
  return true;
}

template <class _RandomAccessIter>
inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last)
{

                                                                              ;
                                                                 ;


  return __is_heap(__first, __last - __first);
}


template <class _RandomAccessIter, class _StrictWeakOrdering>
inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
                    _StrictWeakOrdering __comp)
{

                                                                              ;
                                                                 ;



  return __is_heap(__first, __comp, __last - __first);
}





template <class _ForwardIter>
bool is_sorted(_ForwardIter __first, _ForwardIter __last)
{

                                                                    ;
                                                            ;


  if (__first == __last)
    return true;

  _ForwardIter __next = __first;
  for (++__next; __next != __last; __first = __next, ++__next) {
    if (*__next < *__first)
      return false;
  }

  return true;
}

template <class _ForwardIter, class _StrictWeakOrdering>
bool is_sorted(_ForwardIter __first, _ForwardIter __last,
               _StrictWeakOrdering __comp)
{

                                                                    ;
                                                            ;



  if (__first == __last)
    return true;

  _ForwardIter __next = __first;
  for (++__next; __next != __last; __first = __next, ++__next) {
    if (__comp(*__next, *__first))
      return false;
  }

  return true;
}

}
# 66 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_algorithm.h" 2 3
# 50 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.tcc" 1 3
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.tcc" 3
namespace std
{
  template<typename _CharT, typename _Traits, typename _Alloc>
    const _CharT
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_terminal = _CharT();

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_max_size = (((npos - sizeof(_Rep))/sizeof(_CharT)) - 1) / 4;

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::npos;



  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::_S_empty_rep_storage[
    (sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIter>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                   input_iterator_tag)
      {
        if (__beg == __end && __a == _Alloc())
          return _S_empty_rep()._M_refcopy();

        _CharT __buf[100];
        size_type __i = 0;
        while (__beg != __end && __i < sizeof(__buf) / sizeof(_CharT))
          {
            __buf[__i++] = *__beg;
            ++__beg;
          }
        _Rep* __r = _Rep::_S_create(__i, __a);
        traits_type::copy(__r->_M_refdata(), __buf, __i);
        __r->_M_length = __i;
        try
          {



            for (;;)
              {
                _CharT* __p = __r->_M_refdata() + __r->_M_length;
                _CharT* __last = __r->_M_refdata() + __r->_M_capacity;
                for (;;)
                  {
                    if (__beg == __end)
                      {
                        __r->_M_length = __p - __r->_M_refdata();
                        *__p = _Rep::_S_terminal;
                        return __r->_M_refdata();
                      }
                    if (__p == __last)
                      break;
                    *__p++ = *__beg;
                    ++__beg;
                  }

                size_type __len = __p - __r->_M_refdata();
                _Rep* __another = _Rep::_S_create(__len + 1, __a);
                traits_type::copy(__another->_M_refdata(),
                                  __r->_M_refdata(), __len);
                __r->_M_destroy(__a);
                __r = __another;
                __r->_M_length = __len;
              }
          }
        catch(...)
          {
            __r->_M_destroy(__a);
            throw;
          }
        return 0;
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template <class _InIter>
      _CharT*
      basic_string<_CharT,_Traits,_Alloc>::
      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                   forward_iterator_tag)
      {
        size_type __dnew = static_cast<size_type>(distance(__beg, __end));

        if (__beg == __end && __a == _Alloc())
          return _S_empty_rep()._M_refcopy();


        _Rep* __r = _Rep::_S_create(__dnew, __a);
        try
          { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
        catch(...)
          {
            __r->_M_destroy(__a);
            throw;
          }
        __r->_M_length = __dnew;

        __r->_M_refdata()[__dnew] = _Rep::_S_terminal;
        return __r->_M_refdata();
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT,_Traits, _Alloc>::
    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
    {
      if (__n == 0 && __a == _Alloc())
        return _S_empty_rep()._M_refcopy();


      _Rep* __r = _Rep::_S_create(__n, __a);
      try
        {
          if (__n)
            traits_type::assign(__r->_M_refdata(), __n, __c);
        }
      catch(...)
        {
          __r->_M_destroy(__a);
          throw;
        }
      __r->_M_length = __n;
      __r->_M_refdata()[__n] = _Rep::_S_terminal;
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str)
    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(), __str.get_allocator()),
                 __str.get_allocator())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _Alloc& __a)
    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos, size_type __n)
    : _M_dataplus(_S_construct(__str._M_check(__pos),
                               __str._M_fold(__pos, __n), _Alloc()), _Alloc())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos,
                 size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__str._M_check(__pos),
                               __str._M_fold(__pos, __n), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s + traits_type::length(__s), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
    : _M_dataplus(_S_construct(__n, __c, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIter>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(_InputIter __beg, _InputIter __end, const _Alloc& __a)
    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::assign(const basic_string& __str)
    {
      if (_M_rep() != __str._M_rep())
        {

          allocator_type __a = this->get_allocator();
          _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
          _M_rep()->_M_dispose(__a);
          _M_data(__tmp);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_destroy(const _Alloc& __a) throw ()
    {
      size_type __size = sizeof(_Rep) + (_M_capacity + 1) * sizeof(_CharT);
      _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::_M_leak_hard()
    {
      if (_M_rep()->_M_is_shared())
        _M_mutate(0, 0, 0);
      _M_rep()->_M_set_leaked();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_mutate(size_type __pos, size_type __len1, size_type __len2)
    {
      size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;
      const _CharT* __src = _M_data() + __pos + __len1;
      const size_type __how_much = __old_size - __pos - __len1;

      if (_M_rep()->_M_is_shared() || __new_size > capacity())
        {

          allocator_type __a = get_allocator();
          _Rep* __r = _Rep::_S_create(__new_size, __a);
          try
            {
              if (__pos)
                traits_type::copy(__r->_M_refdata(), _M_data(), __pos);
              if (__how_much)
                traits_type::copy(__r->_M_refdata() + __pos + __len2,
                                  __src, __how_much);
            }
          catch(...)
            {
              __r->_M_dispose(get_allocator());
              throw;
            }
          _M_rep()->_M_dispose(__a);
          _M_data(__r->_M_refdata());
      }
      else if (__how_much && __len1 != __len2)
        {

          traits_type::move(_M_data() + __pos + __len2, __src, __how_much);
        }
      _M_rep()->_M_set_sharable();
      _M_rep()->_M_length = __new_size;
      _M_data()[__new_size] = _Rep::_S_terminal;

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::reserve(size_type __res)
    {
      if (__res > this->capacity() || _M_rep()->_M_is_shared())
        {
          if (__res > this->max_size())
            __throw_length_error("basic_string::reserve");
          allocator_type __a = get_allocator();
          _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
          _M_rep()->_M_dispose(__a);
          _M_data(__tmp);
        }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void basic_string<_CharT, _Traits, _Alloc>::swap(basic_string& __s)
    {
      if (_M_rep()->_M_is_leaked())
        _M_rep()->_M_set_sharable();
      if (__s._M_rep()->_M_is_leaked())
        __s._M_rep()->_M_set_sharable();
      if (this->get_allocator() == __s.get_allocator())
        {
          _CharT* __tmp = _M_data();
          _M_data(__s._M_data());
          __s._M_data(__tmp);
        }

      else
        {
          basic_string __tmp1(_M_ibegin(), _M_iend(), __s.get_allocator());
          basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
                              this->get_allocator());
          *this = __tmp2;
          __s = __tmp1;
        }
    }
# 356 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _S_create(size_t __capacity, const _Alloc& __alloc)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;


      if (__capacity > _S_max_size)



        __throw_length_error("basic_string::_S_create");




      size_t __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);


      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
      _Rep *__p = new (__place) _Rep;
      __p->_M_capacity = __capacity;
      __p->_M_set_sharable();
      __p->_M_length = 0;
      return __p;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_clone(const _Alloc& __alloc, size_type __res)
    {
      _Rep* __r = _Rep::_S_create(_M_length + __res, __alloc);
      if (_M_length)
        {
          try
            { traits_type::copy(__r->_M_refdata(), _M_refdata(), _M_length); }
          catch(...)
            {
              __r->_M_destroy(__alloc);
              throw;
            }
        }
      __r->_M_length = _M_length;
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
  inline bool




    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _S_excess_slop(size_t __s, size_t __r)

    {
      return 2 * (__s <= 16 ? 16 : __s) < __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
    {
      if (__n > max_size())
        __throw_length_error("basic_string::resize");
      size_type __size = this->size();
      if (__size < __n)
        this->append(__n - __size, __c);
      else if (__n < __size)
        this->erase(__n);

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIter>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace(iterator __i1, iterator __i2, _InputIter __k1,
                 _InputIter __k2, input_iterator_tag)
      {
        basic_string __s(__k1, __k2);
        return this->replace(__i1, __i2, __s._M_ibegin(), __s._M_iend());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _ForwardIter>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace(iterator __i1, iterator __i2, _ForwardIter __k1,
                 _ForwardIter __k2, forward_iterator_tag)
      {
        size_type __dold = __i2 - __i1;
        size_type __dmax = this->max_size();
        size_type __dnew = static_cast<size_type>(distance(__k1, __k2));

        if (__dmax <= __dnew)
          __throw_length_error("basic_string::_M_replace");
        size_type __off = __i1 - _M_ibegin();
        _M_mutate(__off, __dold, __dnew);

        if (__dnew)
          _S_copy_chars(_M_data() + __off, __k1, __k2);

        return *this;
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    replace(size_type __pos1, size_type __n1, const basic_string& __str,
            size_type __pos2, size_type __n2)
    {
      return this->replace(_M_check(__pos1), _M_fold(__pos1, __n1),
                           __str._M_check(__pos2),
                           __str._M_fold(__pos2, __n2));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(const basic_string& __str)
    {



      size_type __size = __str.size();
      size_type __len = __size + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return this->replace(_M_iend(), _M_iend(), __str._M_ibegin(),
                           __str._M_iend());
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(const basic_string& __str, size_type __pos, size_type __n)
    {



      size_type __len = min(__str.size() - __pos, __n) + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return this->replace(_M_iend(), _M_iend(), __str._M_check(__pos),
                           __str._M_fold(__pos, __n));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(const _CharT* __s, size_type __n)
    {
      size_type __len = __n + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return this->replace(_M_iend(), _M_iend(), __s, __s + __n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(size_type __n, _CharT __c)
    {
      size_type __len = __n + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
       return this->replace(_M_iend(), _M_iend(), __n, __c);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
             const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
      typedef basic_string<_CharT,_Traits,_Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __size_type __len = _Traits::length(__lhs);
      __string_type __str;
      __str.reserve(__len + __rhs.size());
      __str.append(__lhs, __lhs + __len);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
      typedef basic_string<_CharT,_Traits,_Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str;
      __size_type __len = __rhs.size();
      __str.reserve(__len + 1);
      __str.append(__size_type(1), __lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    replace(iterator __i1, iterator __i2, size_type __n2, _CharT __c)
    {
      size_type __n1 = __i2 - __i1;
      size_type __off1 = __i1 - _M_ibegin();
      if (max_size() - (this->size() - __n1) <= __n2)
        __throw_length_error("basic_string::replace");
      _M_mutate (__off1, __n1, __n2);

      if (__n2)
        traits_type::assign(_M_data() + __off1, __n2, __c);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      if (__pos > this->size())
        __throw_out_of_range("basic_string::copy");

      if (__n > this->size() - __pos)
        __n = this->size() - __pos;

      traits_type::copy(__s, _M_data() + __pos, __n);

      return __n;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      size_t __xpos = __pos;
      const _CharT* __data = _M_data();
      for (; __xpos + __n <= __size; ++__xpos)
        if (traits_type::compare(__data + __xpos, __s, __n) == 0)
          return __xpos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      size_type __ret = npos;
      if (__pos < __size)
        {
          const _CharT* __data = _M_data();
          size_type __n = __size - __pos;
          const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
          if (__p)
            __ret = __p - __data;
        }
      return __ret;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      if (__n <= __size)
        {
          __pos = std::min(__size - __n ,__pos);
          const _CharT* __data = _M_data();
          do
            {
              if (traits_type::compare(__data + __pos, __s, __n) == 0)
                return __pos;
            }
          while (__pos-- > 0);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
        {
          size_t __xpos = __size - 1;
          if (__xpos > __pos)
            __xpos = __pos;

          for (++__xpos; __xpos-- > 0; )
            if (traits_type::eq(_M_data()[__xpos], __c))
              return __xpos;
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      for (; __n && __pos < this->size(); ++__pos)
        {
          const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
          if (__p)
            return __pos;
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      if (__size && __n)
        {
          if (--__size > __pos)
            __size = __pos;
          do
            {
              if (traits_type::find(__s, __n, _M_data()[__size]))
                return __size;
            }
          while (__size-- != 0);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_t __xpos = __pos;
      for (; __n && __xpos < this->size(); ++__xpos)
        if (!traits_type::find(__s, __n, _M_data()[__xpos]))
          return __xpos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const
    {
      size_t __xpos = __pos;
      for (; __xpos < this->size(); ++__xpos)
        if (!traits_type::eq(_M_data()[__xpos], __c))
          return __xpos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      if (__size && __n)
        {
          if (--__size > __pos)
            __size = __pos;
          do
            {
              if (!traits_type::find(__s, __n, _M_data()[__size]))
                return __size;
            }
          while (__size--);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
        {
          if (--__size > __pos)
            __size = __pos;
          do
            {
              if (!traits_type::eq(_M_data()[__size], __c))
                return __size;
            }
          while (__size--);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n, const basic_string& __str) const
    {
      size_type __size = this->size();
      size_type __osize = __str.size();
      if (__pos > __size)
        __throw_out_of_range("basic_string::compare");

      size_type __rsize= min(__size - __pos, __n);
      size_type __len = min(__rsize, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
      if (!__r)
        __r = __rsize - __osize;
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos1, size_type __n1, const basic_string& __str,
            size_type __pos2, size_type __n2) const
    {
      size_type __size = this->size();
      size_type __osize = __str.size();
      if (__pos1 > __size || __pos2 > __osize)
        __throw_out_of_range("basic_string::compare");

      size_type __rsize = min(__size - __pos1, __n1);
      size_type __rosize = min(__osize - __pos2, __n2);
      size_type __len = min(__rsize, __rosize);
      int __r = traits_type::compare(_M_data() + __pos1,
                                     __str.data() + __pos2, __len);
      if (!__r)
        __r = __rsize - __rosize;
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(const _CharT* __s) const
    {
      size_type __size = this->size();
      int __r = traits_type::compare(_M_data(), __s, __size);
      if (!__r)
        __r = __size - traits_type::length(__s);
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT,_Traits,_Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s) const
    {
      size_type __size = this->size();
      if (__pos > __size)
        __throw_out_of_range("basic_string::compare");

      size_type __osize = traits_type::length(__s);
      size_type __rsize = min(__size - __pos, __n1);
      size_type __len = min(__rsize, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
        __r = __rsize - __osize;
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT,_Traits,_Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s,
            size_type __n2) const
    {
      size_type __size = this->size();
      if (__pos > __size)
        __throw_out_of_range("basic_string::compare");

      size_type __osize = min(traits_type::length(__s), __n2);
      size_type __rsize = min(__size - __pos, __n1);
      size_type __len = min(__rsize, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
        __r = __rsize - __osize;
      return __r;
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    _S_string_copy(const basic_string<_CharT, _Traits, _Alloc>& __str,
                   _CharT* __buf, typename _Alloc::size_type __bufsiz)
    {
      typedef typename _Alloc::size_type size_type;
      size_type __strsize = __str.size();
      size_type __bytes = min(__strsize, __bufsiz - 1);
      _Traits::copy(__buf, __str.data(), __bytes);
      __buf[__bytes] = _CharT();
    }
}
# 51 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_string.h" 2 3
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cctype.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cctype.h" 3
# 1 "/usr/include/ctype.h" 1 3 4
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cctype.h" 2 3
# 55 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cctype.h" 3
namespace std
{
  using ::isalnum;
  using ::isalpha;
  using ::iscntrl;
  using ::isdigit;
  using ::isgraph;
  using ::islower;
  using ::isprint;
  using ::ispunct;
  using ::isspace;
  using ::isupper;
  using ::isxdigit;
  using ::tolower;
  using ::toupper;
}
# 44 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception_defines.h" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 45 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 2 3

namespace std
{
# 56 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 3
  template<typename _Tp, typename _Alloc>
    class vector;
  class locale;


  template<typename _CharT>
    inline bool
    isspace(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isprint(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    iscntrl(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isupper(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    islower(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isalpha(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isdigit(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    ispunct(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isxdigit(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isalnum(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isgraph(_CharT, const locale&);

  template<typename _CharT>
    inline _CharT
    toupper(_CharT, const locale&);

  template<typename _CharT>
    inline _CharT
    tolower(_CharT, const locale&);



  class ctype_base;
  template<typename _CharT>
    class ctype;
  template<> class ctype<char>;



  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname;


  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class num_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class num_put;
  template<typename _CharT> class numpunct;
  template<typename _CharT> class numpunct_byname;


  template<typename _CharT>
    class collate;
  template<typename _CharT> class
    collate_byname;


  class time_base;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get_byname;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put_byname;


  class money_base;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class money_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class money_put;
  template<typename _CharT, bool _Intl = false>
    class moneypunct;
  template<typename _CharT, bool _Intl = false>
    class moneypunct_byname;


  class messages_base;
  template<typename _CharT>
    class messages;
  template<typename _CharT>
    class messages_byname;


  class locale
  {
  public:

    typedef unsigned int category;


    class facet;
    class id;
    class _Impl;

    friend class facet;
    friend class _Impl;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();



    static const category none = 0;
    static const category ctype = 1L << 0;
    static const category numeric = 1L << 1;
    static const category collate = 1L << 2;
    static const category time = 1L << 3;
    static const category monetary = 1L << 4;
    static const category messages = 1L << 5;
    static const category all = (collate | ctype | monetary |
                                           numeric | time | messages);


    locale() throw();

    locale(const locale& __other) throw();

    explicit
    locale(const char* __std_name);

    locale(const locale& __base, const char* __s, category __cat);

    locale(const locale& __base, const locale& __add, category __cat);

    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);

    ~locale() throw();

    const locale&
    operator=(const locale& __other) throw();

    template<typename _Facet>
      locale
      combine(const locale& __other);


    string
    name() const;

    bool
    operator==(const locale& __other) const throw ();

    inline bool
    operator!=(const locale& __other) const throw ()
    { return !(this->operator==(__other)); }

    template<typename _Char, typename _Traits, typename _Alloc>
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
                 const basic_string<_Char, _Traits, _Alloc>& __s2) const;


    static locale
    global(const locale&);

    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;

    static const size_t _S_num_categories = 6;
    static const size_t _S_num_facets = 13;

    explicit
    locale(_Impl*) throw();

    static inline void
    _S_initialize()
    { if (!_S_classic) classic(); }

    static category
    _S_normalize_category(category);

    void
    _M_coalesce(const locale& __base, const locale& __add, category __cat);
  };



  class locale::_Impl
  {
  public:

    typedef vector<facet*, allocator<facet*> > __vec_facet;


    friend class locale;
    friend class locale::facet;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

  private:

    size_t _M_references;
    __vec_facet* _M_facets;
    string _M_names[_S_num_categories];
    __c_locale _M_c_locale;
    static const locale::id* const _S_id_ctype[];
    static const locale::id* const _S_id_numeric[];
    static const locale::id* const _S_id_collate[];
    static const locale::id* const _S_id_time[];
    static const locale::id* const _S_id_monetary[];
    static const locale::id* const _S_id_messages[];
    static const locale::id* const* const _S_facet_categories[];

    inline void
    _M_add_reference() throw()
    { ++_M_references; }

    inline void
    _M_remove_reference() throw()
    {
      if (_M_references-- == 0)
        {
          try
            { delete this; }
          catch(...)
            { }
        }
    }

    _Impl(const _Impl&, size_t);
    _Impl(string __name, size_t);
   ~_Impl() throw();

    bool
    _M_check_same_name()
    {
      bool __ret = true;
      for (size_t i = 0; i < _S_num_categories - 1; ++i)
        __ret &= _M_names[i] == _M_names[i + 1];
      return __ret;
    }
    void
    _M_replace_categories(const _Impl*, category);

    void
    _M_replace_category(const _Impl*, const locale::id* const*);

    void
    _M_replace_facet(const _Impl*, const locale::id*);

    void
    _M_install_facet(const locale::id*, facet*);

    template<typename _Facet>
      inline void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }
  };

  template<typename _Facet>
    locale::locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);
      _M_impl->_M_install_facet(&_Facet::id, __f);
      for (size_t __i = 0; __i < _S_num_categories; ++__i)
        _M_impl->_M_names[__i] = "*";
    }


  class locale::facet
  {
    friend class locale;
    friend class locale::_Impl;

  protected:
    explicit
    facet(size_t __refs = 0) throw();

    virtual
    ~facet() { };

    static void
    _S_create_c_locale(__c_locale& __cloc, const char* __s);

    static void
    _S_destroy_c_locale(__c_locale& __cloc);

  private:
    size_t _M_references;

    void
    _M_add_reference() throw();

    void
    _M_remove_reference() throw();

    facet(const facet&);

    void
    operator=(const facet&);
  };



  class locale::id
  {
  private:
    friend class locale;
    friend class locale::_Impl;
    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);
    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw ();




    mutable size_t _M_index;


    static size_t _S_highwater;

    void
    operator=(const id&);

    id(const id&);

  public:



    id() { }
  };

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc);

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw();
}
# 44 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ios_base.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ios_base.h" 3

namespace std
{




  enum _Ios_Fmtflags { _M_ios_fmtflags_end = 1L << 16 };

  inline _Ios_Fmtflags
  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a | __b; }

  inline _Ios_Fmtflags
  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a & __b; }

  inline _Ios_Fmtflags
  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a ^ __b; }

  inline _Ios_Fmtflags
  operator~(_Ios_Fmtflags __a)
  { return _Ios_Fmtflags(~static_cast<int>(__a)); }


  enum _Ios_Openmode { _M_ios_openmode_end = 1L << 16 };

  inline _Ios_Openmode
  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a | __b; }

  inline _Ios_Openmode
  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a & __b; }

  inline _Ios_Openmode
  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a ^ __b; }

  inline _Ios_Openmode
  operator~(_Ios_Openmode __a)
  { return _Ios_Openmode(~static_cast<int>(__a)); }


  enum _Ios_Iostate { _M_ios_iostate_end = 1L << 16 };

  inline _Ios_Iostate
  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a | __b; }

  inline _Ios_Iostate
  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a & __b; }

  inline _Ios_Iostate
  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a ^ __b; }

  inline _Ios_Iostate
  operator~(_Ios_Iostate __a)
  { return _Ios_Iostate(~static_cast<int>(__a)); }

  enum _Ios_Seekdir { _M_ios_seekdir_end = 1L << 16 };


  class ios_base
  {
  public:


    class failure : public exception
    {
    public:


      explicit
      failure(const string& __str) throw();

      virtual
      ~failure() throw();

      virtual const char*
      what() const throw();

    private:
      enum { _M_bufsize = 256 };
      char _M_name[_M_bufsize];

    };


    typedef _Ios_Fmtflags fmtflags;

    static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha);
    static const fmtflags dec = fmtflags(__ios_flags::_S_dec);
    static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed);
    static const fmtflags hex = fmtflags(__ios_flags::_S_hex);
    static const fmtflags internal = fmtflags(__ios_flags::_S_internal);
    static const fmtflags left = fmtflags(__ios_flags::_S_left);
    static const fmtflags oct = fmtflags(__ios_flags::_S_oct);
    static const fmtflags right = fmtflags(__ios_flags::_S_right);
    static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific);
    static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase);
    static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint);
    static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos);
    static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws);
    static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf);
    static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase);
    static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);
    static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield);
    static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield);


    typedef _Ios_Iostate iostate;
    static const iostate badbit = iostate(__ios_flags::_S_badbit);
    static const iostate eofbit = iostate(__ios_flags::_S_eofbit);
    static const iostate failbit = iostate(__ios_flags::_S_failbit);
    static const iostate goodbit = iostate(0);


    typedef _Ios_Openmode openmode;
    static const openmode app = openmode(__ios_flags::_S_app);
    static const openmode ate = openmode(__ios_flags::_S_ate);
    static const openmode binary = openmode(__ios_flags::_S_bin);
    static const openmode in = openmode(__ios_flags::_S_in);
    static const openmode out = openmode(__ios_flags::_S_out);
    static const openmode trunc = openmode(__ios_flags::_S_trunc);


    typedef _Ios_Seekdir seekdir;
    static const seekdir beg = seekdir(0);
    static const seekdir cur = seekdir(1);
    static const seekdir end = seekdir(2);
# 216 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };

    typedef void (*event_callback) (event, ios_base&, int);

    void
    register_callback(event_callback __fn, int __index);

  protected:

    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;



    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      int _M_refcount;

      _Callback_list(ios_base::event_callback __fn, int __index,
                     _Callback_list* __cb)
      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void
      _M_add_reference() { ++_M_refcount; }

      int
      _M_remove_reference() { return _M_refcount--; }
    };

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void);


    struct _Words
    {
      void* _M_pword;
      long _M_iword;
    };

    static const int _S_local_words = 8;
    _Words _M_word_array[_S_local_words];
    _Words _M_dummy;
    _Words* _M_words;
    int _M_word_limit;

    _Words&
    _M_grow_words(int __index);


    locale _M_ios_locale;

    void
    _M_init();

  public:





    class Init
    {
      friend class ios_base;
    public:
      Init();
      ~Init();

      static void
      _S_ios_create(bool __sync);

      static void
      _S_ios_destroy();

    private:
      static int _S_ios_base_init;
      static bool _S_synced_with_stdio;
    };


    inline fmtflags
    flags() const { return _M_flags; }

    inline fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }

    inline fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }

    inline fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }

    inline void
    unsetf(fmtflags __mask) { _M_flags &= ~__mask; }

    inline streamsize
    precision() const { return _M_precision; }

    inline streamsize
    precision(streamsize __prec)
    {
      streamsize __old = _M_precision;
      _M_precision = __prec;
      return __old;
    }

    inline streamsize
    width() const { return _M_width; }

    inline streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }

    static bool
    sync_with_stdio(bool __sync = true);


    locale
    imbue(const locale& __loc);

    inline locale
    getloc() const { return _M_ios_locale; }


    static int
    xalloc() throw();

    inline long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_limit)
                        ? _M_words[__ix] : _M_grow_words(__ix);
      return __word._M_iword;
    }

    inline void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_limit)
                        ? _M_words[__ix] : _M_grow_words(__ix);
      return __word._M_pword;
    }


    ~ios_base();

  protected:
    ios_base();


  private:
    ios_base(const ios_base&);

    ios_base&
    operator=(const ios_base&);

  };


  inline ios_base&
  boolalpha(ios_base& __base)
  {
    __base.setf(ios_base::boolalpha);
    return __base;
  }

  inline ios_base&
  noboolalpha(ios_base& __base)
  {
    __base.unsetf(ios_base::boolalpha);
    return __base;
  }

  inline ios_base&
  showbase(ios_base& __base)
  {
    __base.setf(ios_base::showbase);
    return __base;
  }

  inline ios_base&
  noshowbase(ios_base& __base)
  {
    __base.unsetf(ios_base::showbase);
    return __base;
  }

  inline ios_base&
  showpoint(ios_base& __base)
  {
    __base.setf(ios_base::showpoint);
    return __base;
  }

  inline ios_base&
  noshowpoint(ios_base& __base)
  {
    __base.unsetf(ios_base::showpoint);
    return __base;
  }

  inline ios_base&
  showpos(ios_base& __base)
  {
    __base.setf(ios_base::showpos);
    return __base;
  }

  inline ios_base&
  noshowpos(ios_base& __base)
  {
    __base.unsetf(ios_base::showpos);
    return __base;
  }

  inline ios_base&
  skipws(ios_base& __base)
  {
    __base.setf(ios_base::skipws);
    return __base;
  }

  inline ios_base&
  noskipws(ios_base& __base)
  {
    __base.unsetf(ios_base::skipws);
    return __base;
  }

  inline ios_base&
  uppercase(ios_base& __base)
  {
    __base.setf(ios_base::uppercase);
    return __base;
  }

  inline ios_base&
  nouppercase(ios_base& __base)
  {
    __base.unsetf(ios_base::uppercase);
    return __base;
  }

  inline ios_base&
  unitbuf(ios_base& __base)
  {
     __base.setf(ios_base::unitbuf);
     return __base;
  }

  inline ios_base&
  nounitbuf(ios_base& __base)
  {
     __base.unsetf(ios_base::unitbuf);
     return __base;
  }


  inline ios_base&
  internal(ios_base& __base)
  {
     __base.setf(ios_base::internal, ios_base::adjustfield);
     return __base;
  }

  inline ios_base&
  left(ios_base& __base)
  {
    __base.setf(ios_base::left, ios_base::adjustfield);
    return __base;
  }

  inline ios_base&
  right(ios_base& __base)
  {
    __base.setf(ios_base::right, ios_base::adjustfield);
    return __base;
  }


  inline ios_base&
  dec(ios_base& __base)
  {
    __base.setf(ios_base::dec, ios_base::basefield);
    return __base;
  }

  inline ios_base&
  hex(ios_base& __base)
  {
    __base.setf(ios_base::hex, ios_base::basefield);
    return __base;
  }

  inline ios_base&
  oct(ios_base& __base)
  {
    __base.setf(ios_base::oct, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  fixed(ios_base& __base)
  {
    __base.setf(ios_base::fixed, ios_base::floatfield);
    return __base;
  }

  inline ios_base&
  scientific(ios_base& __base)
  {
    __base.setf(ios_base::scientific, ios_base::floatfield);
    return __base;
  }

}
# 45 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iosfwd.h" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdio.h" 1 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 1 3
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ios_base.h" 1 3
# 44 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 2 3

namespace std
{
  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_ios<_CharT, _Traits>& _ios,
                      basic_streambuf<_CharT, _Traits>* __sbin,
                      basic_streambuf<_CharT, _Traits>* __sbout);


  template<typename _CharT, typename _Traits>
    class basic_streambuf
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef ctype<char_type> __ctype_type;
      typedef basic_streambuf<char_type, traits_type> __streambuf_type;

      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      __copy_streambufs<>(basic_ios<char_type, traits_type>& __ios,
                          __streambuf_type* __sbin,__streambuf_type* __sbout);

    protected:






      char_type* _M_buf;


      int_type _M_buf_size;


      int_type _M_buf_size_opt;



      bool _M_buf_unified;






      char_type* _M_in_beg;
      char_type* _M_in_cur;
      char_type* _M_in_end;
      char_type* _M_out_beg;
      char_type* _M_out_cur;
      char_type* _M_out_end;


      ios_base::openmode _M_mode;


      locale _M_buf_locale;


      bool _M_buf_locale_init;






      int_type _M_pback_size;
      char_type* _M_pback;
      char_type* _M_pback_cur_save;
      char_type* _M_pback_end_save;
      bool _M_pback_init;




      void
      _M_pback_create()
      {
        if (!_M_pback_init)
          {
            int_type __dist = _M_in_end - _M_in_cur;
            int_type __len = min(_M_pback_size, __dist);
            traits_type::copy(_M_pback, _M_in_cur, __len);
            _M_pback_cur_save = _M_in_cur;
            _M_pback_end_save = _M_in_end;
            this->setg(_M_pback, _M_pback, _M_pback + __len);
            _M_pback_init = true;
          }
      }




      void
      _M_pback_destroy()
      {
        if (_M_pback_init)
          {

            int_type __off_cur = _M_in_cur - _M_pback;


            int_type __off_end = 0;
            int_type __pback_len = _M_in_end - _M_pback;
            int_type __save_len = _M_pback_end_save - _M_buf;
            if (__pback_len > __save_len)
              __off_end = __pback_len - __save_len;

            this->setg(_M_buf, _M_pback_cur_save + __off_cur,
                       _M_pback_end_save + __off_end);
            _M_pback_cur_save = __null;
            _M_pback_end_save = __null;
            _M_pback_init = false;
          }
      }



      void
      _M_in_cur_move(off_type __n)
      {
        bool __testout = _M_out_cur;
        _M_in_cur += __n;
        if (__testout && _M_buf_unified)
          _M_out_cur += __n;
      }
# 193 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 3
      void
      _M_out_cur_move(off_type __n)
      {
        bool __testin = _M_in_cur;

        _M_out_cur += __n;
        if (__testin && _M_buf_unified)
          _M_in_cur += __n;
        if (_M_out_cur > _M_out_end)
          {
            _M_out_end = _M_out_cur;

            if (__testin)
              _M_in_end += __n;
          }
      }




      off_type
      _M_out_buf_size()
      {
        off_type __ret = 0;
        if (_M_out_cur)
          {

            if (_M_out_beg == _M_buf)
              __ret = _M_out_beg + _M_buf_size - _M_out_cur;

            else
              __ret = _M_out_end - _M_out_cur;
          }
        return __ret;
      }
# 236 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 3
      void
      _M_set_indeterminate(void)
      {
        if (_M_mode & ios_base::in)
          this->setg(_M_buf, _M_buf, _M_buf);
        if (_M_mode & ios_base::out)
          this->setp(_M_buf, _M_buf);
      }

      void
      _M_set_determinate(off_type __off)
      {
        bool __testin = _M_mode & ios_base::in;
        bool __testout = _M_mode & ios_base::out;
        if (__testin)
          this->setg(_M_buf, _M_buf, _M_buf + __off);
        if (__testout)
          this->setp(_M_buf, _M_buf + __off);
      }

      bool
      _M_is_indeterminate(void)
      {
        bool __ret = false;

        if (_M_buf)
          {
            if (_M_mode & ios_base::in)
              __ret = _M_in_beg == _M_in_cur && _M_in_cur == _M_in_end;
            if (_M_mode & ios_base::out)
              __ret = _M_out_beg == _M_out_cur && _M_out_cur == _M_out_end;
          }
        return __ret;
      }

  public:
      virtual
      ~basic_streambuf()
      {
        _M_buf_unified = false;
        _M_buf_size = 0;
        _M_buf_size_opt = 0;
        _M_mode = ios_base::openmode(0);
        _M_buf_locale_init = false;
      }


      locale
      pubimbue(const locale &__loc)
      {
        locale __tmp(this->getloc());
        this->imbue(__loc);
        return __tmp;
      }

      locale
      getloc() const
      {
        if (_M_buf_locale_init)
          return _M_buf_locale;
        else
          return locale();
      }


      __streambuf_type*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }

      pos_type
      pubseekoff(off_type __off, ios_base::seekdir __way,
                 ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekoff(__off, __way, __mode); }

      pos_type
      pubseekpos(pos_type __sp,
                 ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekpos(__sp, __mode); }

      int
      pubsync() { return this->sync(); }



      streamsize
      in_avail()
      {
        streamsize __ret;
        if (_M_in_cur && _M_in_cur < _M_in_end)
          {
            if (_M_pback_init)
              {
                int_type __save_len = _M_pback_end_save - _M_pback_cur_save;
                int_type __pback_len = _M_in_cur - _M_pback;
                __ret = __save_len - __pback_len;
              }
            else
              __ret = this->egptr() - this->gptr();
          }
        else
          __ret = this->showmanyc();
        return __ret;
      }

      int_type
      snextc()
      {
        int_type __eof = traits_type::eof();
        return (this->sbumpc() == __eof ? __eof : this->sgetc());
      }

      int_type
      sbumpc();

      int_type
      sgetc()
      {
        int_type __ret;
        if (_M_in_cur && _M_in_cur < _M_in_end)
          __ret = traits_type::to_int_type(*(this->gptr()));
        else
          __ret = this->underflow();
        return __ret;
      }

      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }


      int_type
      sputbackc(char_type __c);

      int_type
      sungetc();


      int_type
      sputc(char_type __c);

      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
      basic_streambuf()
      : _M_buf(__null), _M_buf_size(0),
      _M_buf_size_opt(static_cast<int_type>(1024)), _M_buf_unified(false),
      _M_in_beg(0), _M_in_cur(0), _M_in_end(0), _M_out_beg(0), _M_out_cur(0),
      _M_out_end(0), _M_mode(ios_base::openmode(0)), _M_buf_locale(locale()),
      _M_buf_locale_init(false), _M_pback_size(1), _M_pback(__null),
      _M_pback_cur_save(__null), _M_pback_end_save(__null), _M_pback_init(false)
      { }


      char_type*
      eback() const { return _M_in_beg; }

      char_type*
      gptr() const { return _M_in_cur; }

      char_type*
      egptr() const { return _M_in_end; }

      void
      gbump(int __n) { _M_in_cur += __n; }

      void
      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
      {
        _M_in_beg = __gbeg;
        _M_in_cur = __gnext;
        _M_in_end = __gend;
        if (!(_M_mode & ios_base::in) && __gbeg && __gnext && __gend)
          _M_mode = _M_mode | ios_base::in;
      }


      char_type*
      pbase() const { return _M_out_beg; }

      char_type*
      pptr() const { return _M_out_cur; }

      char_type*
      epptr() const { return _M_out_end; }

      void
      pbump(int __n) { _M_out_cur += __n; }

      void
      setp(char_type* __pbeg, char_type* __pend)
      {
        _M_out_beg = _M_out_cur = __pbeg;
        _M_out_end = __pend;
        if (!(_M_mode & ios_base::out) && __pbeg && __pend)
          _M_mode = _M_mode | ios_base::out;
      }



      virtual void
      imbue(const locale& __loc)
      {
        _M_buf_locale_init = true;
        if (_M_buf_locale != __loc)
          _M_buf_locale = __loc;
      }


      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }

      virtual pos_type
      seekoff(off_type, ios_base::seekdir,
              ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }

      virtual pos_type
      seekpos(pos_type,
              ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }

      virtual int
      sync() { return 0; }


      virtual streamsize
      showmanyc() { return 0; }

      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);

      virtual int_type
      underflow()
      { return traits_type::eof(); }

      virtual int_type
      uflow()
      {
        int_type __ret = traits_type::eof();
        bool __testeof = this->underflow() == __ret;
        bool __testpending = _M_in_cur && _M_in_cur < _M_in_end;
        if (!__testeof && __testpending)
          {
            __ret = traits_type::to_int_type(*_M_in_cur);
            ++_M_in_cur;
            if (_M_buf_unified && _M_mode & ios_base::out)
              ++_M_out_cur;
          }
        return __ret;
      }


      virtual int_type
      pbackfail(int_type = traits_type::eof())
      { return traits_type::eof(); }


      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);

      virtual int_type
      overflow(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 516 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 3
    private:
      basic_streambuf(const __streambuf_type&);

      __streambuf_type&
      operator=(const __streambuf_type&);

    };

}




# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/streambuf.tcc" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/streambuf.tcc" 3
namespace std {

  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sbumpc()
    {
      int_type __ret;
      if (_M_in_cur && _M_in_cur < _M_in_end)
        {
          char_type __c = *gptr();
          _M_in_cur_move(1);
          __ret = traits_type::to_int_type(__c);
        }
      else
        __ret = this->uflow();
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sputbackc(char_type __c)
    {
      int_type __ret;
      bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;
      bool __testne = _M_in_cur && !traits_type::eq(__c, this->gptr()[-1]);
      if (!__testpos || __testne)
        __ret = pbackfail(traits_type::to_int_type(__c));
      else
        {
          _M_in_cur_move(-1);
          __ret = traits_type::to_int_type(*this->gptr());
        }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sungetc()
    {
      int_type __ret;
      if (_M_in_cur && _M_in_beg < _M_in_cur)
        {
          _M_in_cur_move(-1);
          __ret = traits_type::to_int_type(*_M_in_cur);
        }
      else
        __ret = this->pbackfail();
      return __ret;
    }






  template<typename _CharT, typename _Traits>
    typename basic_streambuf<_CharT, _Traits>::int_type
    basic_streambuf<_CharT, _Traits>::
    sputc(char_type __c)
    {
      int_type __ret;
      if (_M_out_buf_size())
        {
          *_M_out_cur = __c;
          _M_out_cur_move(1);
          __ret = traits_type::to_int_type(__c);
        }
      else
        __ret = this->overflow(traits_type::to_int_type(__c));
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
        {
          size_t __buf_len = _M_in_end - _M_in_cur;
          if (__buf_len > 0)
            {
              size_t __remaining = __n - __ret;
              size_t __len = min(__buf_len, __remaining);
              traits_type::copy(__s, _M_in_cur, __len);
              __ret += __len;
              __s += __len;
              _M_in_cur_move(__len);
            }

          if (__ret < __n)
            {
              int_type __c = this->uflow();
              if (__c != traits_type::eof())
                {
                  traits_type::assign(*__s++, traits_type::to_char_type(__c));
                  ++__ret;
                }
              else
                break;
            }
        }
      return __ret;
    }






  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsputn(const char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
        {
          off_type __buf_len = _M_out_buf_size();
          if (__buf_len > 0)
            {
              off_type __remaining = __n - __ret;
              off_type __len = min(__buf_len, __remaining);
              traits_type::copy(_M_out_cur, __s, __len);
              __ret += __len;
              __s += __len;
              _M_out_cur_move(__len);
            }

          if (__ret < __n)
            {
              int_type __c = this->overflow(traits_type::to_int_type(*__s));
              if (__c != traits_type::eof())
                {
                  ++__ret;
                  ++__s;
                }
              else
                break;
            }
        }
      return __ret;
    }





  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_ios<_CharT, _Traits>& __ios,
                      basic_streambuf<_CharT, _Traits>* __sbin,
                      basic_streambuf<_CharT, _Traits>* __sbout)
  {
      typedef typename _Traits::int_type int_type;

      streamsize __ret = 0;
      streamsize __bufsize = __sbin->in_avail();
      streamsize __xtrct;
      bool __testput = __sbout->_M_mode & ios_base::out;
      try {
        while (__testput && __bufsize != -1)
          {
            __xtrct = __sbout->sputn(__sbin->gptr(), __bufsize);
            __ret += __xtrct;
            __sbin->_M_in_cur_move(__xtrct);
            if (__xtrct == __bufsize)
              {
                int_type __c = __sbin->sgetc();
                if (__c == _Traits::eof())
                  {
                    __ios.setstate(ios_base::eofbit);
                    break;
                  }
                __bufsize = __sbin->in_avail();
              }
            else
              break;
          }
      }
      catch(exception& __fail) {
        if ((__ios.exceptions() & ios_base::failbit) != 0)
          throw;
      }
      return __ret;
    }
}
# 530 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_streambuf.h" 2 3
# 46 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/sbuf_iter.h" 1 3
# 36 "/usr/local/gcc-3.0.1/include/g++-v3/bits/sbuf_iter.h" 3

namespace std
{
  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:
      inline
      ostreambuf_iterator(ostream_type& __s) throw ()
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }

      ostreambuf_iterator(streambuf_type* __s) throw ()
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }

      ostreambuf_iterator&
      operator=(_CharT __c);

      ostreambuf_iterator&
      operator*() throw()
      { return *this; }

      ostreambuf_iterator&
      operator++(int) throw()
      { return *this; }

      ostreambuf_iterator&
      operator++() throw()
      { return *this; }

      bool
      failed() const throw()
      { return _M_failed; }
    };

  template<typename _CharT, typename _Traits>
    inline ostreambuf_iterator<_CharT, _Traits>&
    ostreambuf_iterator<_CharT, _Traits>::operator=(_CharT __c)
    {
      if (!_M_failed &&
          _Traits::eq_int_type(_M_sbuf->sputc(__c),_Traits::eof()))
      _M_failed = true;
      return *this;
    }



  template<typename _CharT, typename _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
                      _CharT*, _CharT&>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

      typedef istreambuf_iterator<_CharT, _Traits> __istreambufiter_type;

    private:







      streambuf_type* _M_sbuf;
      int_type _M_c;

    public:
      istreambuf_iterator() throw()
      : _M_sbuf(__null), _M_c(-2) { }

      istreambuf_iterator(istream_type& __s) throw()
      : _M_sbuf(__s.rdbuf()), _M_c(-2) { }

      istreambuf_iterator(streambuf_type* __s) throw()
      : _M_sbuf(__s), _M_c(-2) { }




      char_type
      operator*() const
      {

        char_type __ret;
        if (_M_sbuf && _M_c != static_cast<int_type>(-2))
          __ret = _M_c;
        else if (_M_sbuf)
          __ret = traits_type::to_char_type(_M_sbuf->sgetc());
        else
          __ret = static_cast<char_type>(traits_type::eof());
        return __ret;
      }

      __istreambufiter_type&
      operator++()
      {
        if (_M_sbuf)
          _M_sbuf->sbumpc();
        _M_c = -2;
        return *this;
      }

      __istreambufiter_type
      operator++(int)
      {
        __istreambufiter_type __old = *this;
        if (_M_sbuf)
          __old._M_c = _M_sbuf->sbumpc();
        _M_c = -2;
        return __old;
      }

      bool
      equal(const __istreambufiter_type& __b)
      {
        int_type __eof = traits_type::eof();
        bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof;
        bool __beof = !__b._M_sbuf
                      || __b._M_sbuf->sgetc() == __eof;
        return (__thiseof && __beof || (!__thiseof && !__beof));
      }




      bool
      equal(const __istreambufiter_type& __b) const
      {
        int_type __eof = traits_type::eof();
        bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof;
        bool __beof = !__b._M_sbuf
                      || __b._M_sbuf->sgetc() == __eof;
        return (__thiseof && __beof || (!__thiseof && !__beof));
      }

    };

  template<typename _CharT, typename _Traits>
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
               const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }

  template<typename _CharT, typename _Traits>
    inline bool
    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
               const istreambuf_iterator<_CharT, _Traits>& __b)
    { return !__a.equal(__b); }
}
# 36 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ctime.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ctime.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ctime.h" 2 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ctime.h" 3
# 1 "/usr/include/time.h" 1 3 4
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ctime.h" 2 3
# 53 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ctime.h" 3
namespace std
{
  using ::clock_t;
  using ::time_t;
  using ::tm;

  using ::clock;
  using ::difftime;
  using ::mktime;
  using ::time;
  using ::asctime;
  using ::ctime;
  using ::gmtime;
  using ::localtime;
  using ::strftime;
}
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 1 3
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 2 3






namespace std
{


# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/ctype_base.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/ctype_base.h" 3
  struct ctype_base
  {

    typedef int* __to_type;



    typedef unsigned int mask;
    static const mask upper = 0x00000001;
    static const mask lower = 0x00000002;
    static const mask alpha = 0x00004000;
    static const mask digit = 0x00000004;
    static const mask xdigit = 0x00000080;
    static const mask space = 0x00000008;
    static const mask print = 0x00008000;
    static const mask graph = 0x00002000;
    static const mask cntrl = 0x00000020;
    static const mask punct = 0x00000010;
    static const mask alnum = (0x00004000 | 0x00000004);
  };
# 54 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 2 3


  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:

      typedef _CharT char_type;

      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }

      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }

      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }

      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }

      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }

      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }

      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }

      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }

      char_type
      widen(char __c) const
      { return this->do_widen(__c); }

      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }

      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }

      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
              char __dfault, char *__to) const
      { return this->do_narrow(__lo, __hi, __dfault, __to); }

    protected:
      explicit
      __ctype_abstract_base(size_t __refs = 0): locale::facet(__refs) { }

      virtual
      ~__ctype_abstract_base() { }

      virtual bool
      do_is(mask __m, char_type __c) const = 0;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
            mask* __vec) const = 0;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
                 const char_type* __hi) const = 0;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const = 0;

      virtual char_type
      do_toupper(char_type) const = 0;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;

      virtual char_type
      do_tolower(char_type) const = 0;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;

      virtual char_type
      do_widen(char) const = 0;

      virtual const char*
      do_widen(const char* __lo, const char* __hi,
               char_type* __dest) const = 0;

      virtual char
      do_narrow(char_type, char __dfault) const = 0;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
                 char __dfault, char* __dest) const = 0;
    };


  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename ctype::mask mask;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

      static locale::id id;

   protected:
      virtual
      ~ctype() { }

      virtual bool
      do_is(mask __m, char_type __c) const
      { return false; }

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const
      { return __hi; }

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return __hi; }

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const
      { return __hi; }

      virtual char_type
      do_toupper(char_type __c) const
      { return __c; }

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const
      { return __hi; }

      virtual char_type
      do_tolower(char_type __c) const
      { return __c; }

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const
      { return __hi; }

      virtual char_type
      do_widen(char __c) const
      { return char_type(); }

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const
      { return __hi; }

      virtual char
      do_narrow(char_type, char __dfault) const
      { return __dfault; }

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
                char __dfault, char* __dest) const
      { return __hi; }
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;


  template<>
    class ctype<char> : public __ctype_abstract_base<char>
    {
    public:

      typedef char char_type;

    private:

      bool _M_del;
      __to_type const& _M_toupper;
      __to_type const& _M_tolower;
      const mask* const& _M_ctable;
      const mask* _M_table;

    public:
      static locale::id id;
      static const size_t table_size = 1 + static_cast<unsigned char>(-1);

      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);

      inline bool
      is(mask __m, char __c) const;

      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;

      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;

      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;

    protected:
      virtual
      ~ctype();

      const mask*
      table() const throw()
      { return _M_table; }

      const mask*
      classic_table() throw()
      { return _M_ctable; }

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
                 char __dfault, char* __dest) const;
    };

  template<>
    const ctype<char>&
    use_facet<ctype<char> >(const locale& __loc);
# 392 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/ctype_inline.h" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/ctype_inline.h" 3
  bool
  ctype<char>::
  is(mask __m, char __c) const
  { return _M_table[__c] & __m; }

  const char*
  ctype<char>::
  is(const char* __low, const char* __high, mask* __vec) const
  {
    while (__low < __high)
      *__vec++ = _M_table[*__low++];
    return __high;
  }

  const char*
  ctype<char>::
  scan_is(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high && !(_M_table[*__low] & __m))
      ++__low;
    return __low;
  }

  const char*
  ctype<char>::
  scan_not(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
           && (_M_table[*__low] & __m) != 0)
      ++__low;
    return __low;
  }
# 393 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 2 3


  template<typename _CharT>
    class ctype_byname : public ctype<_CharT>
    {
    public:
      typedef _CharT char_type;

      explicit
      ctype_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~ctype_byname() { }
    };


  template<>
    ctype_byname<char>::ctype_byname(const char*, size_t refs);



# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/codecvt.h" 1 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/codecvt.h" 3
# 173 "/usr/local/gcc-3.0.1/include/g++-v3/bits/codecvt.h" 3
  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };





  template<typename _InternT, typename _ExternT, typename _StateT>
    class __codecvt_abstract_base
    : public locale::facet, public codecvt_base
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;


      result
      out(state_type& __state, const intern_type* __from,
          const intern_type* __from_end, const intern_type*& __from_next,
          extern_type* __to, extern_type* __to_end,
          extern_type*& __to_next) const
      {
        return this->do_out(__state, __from, __from_end, __from_next,
                            __to, __to_end, __to_next);
      }

      result
      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
              extern_type*& __to_next) const
      { return this->do_unshift(__state, __to,__to_end,__to_next); }

      result
      in(state_type& __state, const extern_type* __from,
         const extern_type* __from_end, const extern_type*& __from_next,
         intern_type* __to, intern_type* __to_end,
         intern_type*& __to_next) const
      {
        return this->do_in(__state, __from, __from_end, __from_next,
                           __to, __to_end, __to_next);
      }

      int
      encoding() const throw()
      { return this->do_encoding(); }

      bool
      always_noconv() const throw()
      { return this->do_always_noconv(); }

      int
      length(const state_type& __state, const extern_type* __from,
             const extern_type* __end, size_t __max) const
      { return this->do_length(__state, __from, __end, __max); }

      int
      max_length() const throw()
      { return this->do_max_length(); }

    protected:
      explicit
      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~__codecvt_abstract_base() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const = 0;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const = 0;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
            const extern_type* __from_end, const extern_type*& __from_next,
            intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const = 0;

      virtual int
      do_encoding() const throw() = 0;

      virtual bool
      do_always_noconv() const throw() = 0;

      virtual int
      do_length(const state_type&, const extern_type* __from,
                const extern_type* __end, size_t __max) const = 0;

      virtual int
      do_max_length() const throw() = 0;
    };



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt
    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;


      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT,_ExternT,_StateT> (__refs) { }

    protected:
      virtual
      ~codecvt() { }
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;
# 594 "/usr/local/gcc-3.0.1/include/g++-v3/bits/codecvt.h" 3
  template<>
    class codecvt<char, char, mbstate_t>
    : public __codecvt_abstract_base<char, char, mbstate_t>
    {
    public:

      typedef char intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;


      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
            const extern_type* __from_end, const extern_type*& __from_next,
            intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(const state_type&, const extern_type* __from,
                const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };
# 700 "/usr/local/gcc-3.0.1/include/g++-v3/bits/codecvt.h" 3
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs) { }
    protected:
      virtual
      ~codecvt_byname() { }
    };
# 416 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 2 3

  template<typename _CharT, typename _InIter>
    class _Numeric_get;






  template<typename _CharT>
    class _Format_cache
    {
    public:

      typedef _CharT char_type;
      typedef char_traits<_CharT> traits_type;
      typedef basic_string<_CharT> string_type;
      typedef typename string_type::size_type size_type;


      friend class locale;
      template<typename _Char, typename _InIter>
        friend class _Numeric_get;
      friend class num_get<_CharT>;
      friend class num_put<_CharT>;
      friend class time_get<_CharT>;
      friend class money_get<_CharT>;
      friend class time_put<_CharT>;
      friend class money_put<_CharT>;




      static int _S_pword_ix;



      bool _M_valid;



      static const char _S_literals[];




      enum
      {
        _S_minus,
        _S_plus,
        _S_x,
        _S_X,
        _S_digits,
        _S_digits_end = _S_digits + 16,
        _S_udigits = _S_digits_end,
        _S_udigits_end = _S_udigits + 16,
        _S_ee = _S_digits + 14,
        _S_Ee = _S_udigits + 14
      };




      char_type _M_decimal_point;





      char_type _M_thousands_sep;



      string_type _M_truename;
      string_type _M_falsename;



      bool _M_use_grouping;



      string _M_grouping;

      _Format_cache();

      ~_Format_cache() throw() { }




      static _Format_cache<_CharT>*
      _S_get(ios_base& __ios);

      void
      _M_populate(ios_base&);

      static void
      _S_callback(ios_base::event __event, ios_base& __ios, int __ix) throw();
    };

  template<typename _CharT>
    int _Format_cache<_CharT>::_S_pword_ix;

  template<typename _CharT>
    const char _Format_cache<_CharT>::
    _S_literals[] = "-+xX0123456789abcdef0123456789ABCDEF";

   template<> _Format_cache<char>::_Format_cache();






  template<typename _CharT, typename _InIter>
    class _Numeric_get
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;


      template<typename _Char, typename _InIterT>
      friend class num_get;
      template<typename _Char, typename _InIterT>
      friend class time_get;
      template<typename _Char, typename _InIterT>
      friend class money_get;
      template<typename _Char, typename _InIterT>
      friend class num_put;
      template<typename _Char, typename _InIterT>
      friend class time_put;
      template<typename _Char, typename _InIterT>
      friend class money_put;

    private:
      explicit
      _Numeric_get() { }

      virtual
      ~_Numeric_get() { }

      iter_type
      _M_get_digits(iter_type __in, iter_type __end) const;
    };

  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef char_traits<_CharT> __traits_type;

      static locale::id id;

      explicit
      num_get(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, bool& __v) const
      { return do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, short& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, int& __v) const
      { return do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, long& __v) const
      { return do_get(__in, __end, __io, __err, __v); }
# 607 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned short& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned int& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned long& __v) const
      { return do_get(__in, __end, __io, __err, __v); }
# 629 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, float& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, double& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, long double& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, void*& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

    protected:
      virtual ~num_get() { }





      void
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
                 ios_base::iostate& __err, char* __xtrc,
                 int& __base, bool __fp = true) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, short&) const;
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, int&) const;

      virtual iter_type
      do_get (iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const;





      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
              unsigned short&) const;
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&,
              ios_base::iostate& __err, unsigned int&) const;
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&,
              ios_base::iostate& __err, unsigned long&) const;





      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             float&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             double&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&,
             ios_base::iostate& __err, long double&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             void*&) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;


  template<>
    void
    num_get<char, istreambuf_iterator<char> >::
    _M_extract(istreambuf_iterator<char> __beg,
               istreambuf_iterator<char> __end, ios_base& __io,
               ios_base::iostate& __err, char* __xtrc,
               int& __base, bool __fp) const;



  template<typename _CharT, typename _OutIter>
    class _Numeric_put
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;
    protected:
      explicit
      _Numeric_put() { }

      virtual
      ~_Numeric_put() { }
    };

  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      static locale::id id;

      explicit
      num_put(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          unsigned long __v) const
      { return do_put(__s, __f, __fill, __v); }
# 773 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          long double __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          const void* __v) const
      { return do_put(__s, __f, __fill, __v); }

    protected:
      virtual
      ~num_put() { };

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, bool __v) const;

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, long __v) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, unsigned long) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, double __v) const;

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, long double __v) const;

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;

  template<typename _CharT>
    class numpunct : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

    private:
      char_type _M_decimal_point;
      char_type _M_thousands_sep;
      string _M_grouping;
      string_type _M_truename;
      string_type _M_falsename;

    public:
      explicit
      numpunct(size_t __refs = 0) : locale::facet(__refs)
      { _M_initialize_numpunct(); }

      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0) : locale::facet(__refs)
      { _M_initialize_numpunct(__cloc); }

      char_type
      decimal_point() const
      { return do_decimal_point(); }

      char_type
      thousands_sep() const
      { return do_thousands_sep(); }

      string
      grouping() const
      { return do_grouping(); }

      string_type
      truename() const
      { return do_truename(); }

      string_type
      falsename() const
      { return do_falsename(); }

    protected:
      virtual
      ~numpunct() { }

      virtual char_type
      do_decimal_point() const
      { return _M_decimal_point; }

      virtual char_type
      do_thousands_sep() const
      { return _M_thousands_sep; }

      virtual string
      do_grouping() const
      { return _M_grouping; }

      virtual string_type
      do_truename() const
      { return _M_truename; }

      virtual string_type
      do_falsename() const
      { return _M_falsename; }


      void
      _M_initialize_numpunct(__c_locale __cloc = __null);
    };

  template<typename _CharT>
    locale::id numpunct<_CharT>::id;

  template<typename _CharT>
    void
    numpunct<_CharT>::_M_initialize_numpunct(__c_locale )
    {

    }

  template<>
    void
    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);







  template<typename _CharT>
    class numpunct_byname : public numpunct<_CharT>
    {
      __c_locale _M_c_locale_numpunct;
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      numpunct_byname(const char* __s, size_t __refs = 0)
      : numpunct<_CharT>(__refs)
      {
        _S_create_c_locale(_M_c_locale_numpunct, __s);
        _M_initialize_numpunct(_M_c_locale_numpunct);
      }

    protected:
      virtual
      ~numpunct_byname()
      { _S_destroy_c_locale(_M_c_locale_numpunct); }
    };


  template<typename _CharT>
    class collate : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      collate(size_t __refs = 0) : locale::facet(__refs) { }

      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
              const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }

      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }

      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_hash(__lo, __hi); }

  protected:
      ~collate() { }

      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
                 const _CharT* __lo2, const _CharT* __hi2) const;

      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;

      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const;
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;


  template<>
    int
    collate<char>::do_compare(const char* __lo1, const char* __hi1,
                              const char* __lo2, const char* __hi2) const;

  template<>
    string
    collate<char>::do_transform(const char* __lo, const char* __hi) const;

  template<>
    long
    collate<char>::do_hash(const char* __lo, const char* __hi) const;
# 1014 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 3
  template<typename _CharT>
    class collate_byname : public collate<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      collate_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~collate_byname() { }
    };

  template<>
    collate_byname<char>::collate_byname(const char*, size_t __refs);





  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      static locale::id id;

      explicit
      time_get(size_t __refs = 0)
      : locale::facet (__refs), _M_daynames(0), _M_monthnames(0) { }

      dateorder
      date_order() const
      { return do_date_order(); }

      iter_type
      get_time(iter_type __s, iter_type __end, ios_base& __f,
               ios_base::iostate& __err, tm* __t) const
      { return do_get_time(__s, __end, __f, __err, __t); }

      iter_type
      get_date(iter_type __s, iter_type __end, ios_base& __f,
               ios_base::iostate& __err, tm* __t) const
      { return do_get_date(__s, __end, __f, __err, __t); }

      iter_type
      get_weekday(iter_type __s, iter_type __end, ios_base& __f,
                  ios_base::iostate& __err, tm* __t) const
      { return do_get_weekday(__s,__end,__f,__err,__t); }

      iter_type
      get_monthname(iter_type __s, iter_type __end, ios_base& __f,
                    ios_base::iostate& __err, tm* __t) const
      { return do_get_monthname(__s,__end,__f,__err,__t); }

      iter_type
      get_year(iter_type __s, iter_type __end, ios_base& __f,
               ios_base::iostate& __err, tm* __t) const
      { return do_get_year(__s,__end,__f,__err,__t); }

    protected:
      virtual
      ~time_get()
      {
        delete [] _M_monthnames;
        delete [] _M_daynames;
      }

      virtual dateorder
      do_date_order() const
      { return time_base::ymd; }

      virtual iter_type
      do_get_time(iter_type __s, iter_type , ios_base&,
                  ios_base::iostate& , tm* ) const
      { return __s; }

      virtual iter_type
      do_get_date(iter_type __s, iter_type , ios_base&,
                  ios_base::iostate& , tm* ) const
      { return __s; }

      virtual iter_type
      do_get_weekday(iter_type __s, iter_type __end, ios_base&,
                     ios_base::iostate& __err, tm* __t) const;

      virtual iter_type
      do_get_monthname(iter_type __s, iter_type __end, ios_base&,
                       ios_base::iostate& __err, tm* __t) const;

      virtual iter_type
      do_get_year(iter_type __s, iter_type , ios_base&,
                   ios_base::iostate& , tm* ) const
      { return __s; }

      mutable basic_string<_CharT>* _M_daynames;
      mutable basic_string<_CharT>* _M_monthnames;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;

  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:
      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }
    protected:
      virtual
      ~time_get_byname() { }
    };

  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet, public time_base
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;

      static locale::id id;

      explicit
      time_put(size_t __refs = 0) : locale::facet (__refs) { }


      iter_type
      put(iter_type __s, ios_base& , char_type ,
          const tm* , const _CharT* ,
          const _CharT* ) const
      { return __s; }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          const tm* __tmb, char __format, char __modifier = 0) const
      { return do_put(__s, __f, __fill, __tmb, __format, __modifier); }

    protected:
      virtual
      ~time_put() { }

      virtual iter_type
      do_put(iter_type __s, ios_base&, char_type, const tm* ,
             char , char ) const
      { return __s; }
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;

  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char*, size_t __refs = 0)
      : time_put<_CharT, _OutIter> (__refs) { }

    protected:
      virtual
      ~time_put_byname() { }
    };


  template<typename _CharT, typename _InIter>
    class money_get : public locale::facet
    {
    public:
      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      money_get(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      get(iter_type __s, iter_type __end, bool __intl,
          ios_base& __f, ios_base::iostate& __err, long double& __units) const
      { return do_get(__s, __end, __intl, __f, __err, __units); }

      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __f,
           ios_base::iostate& __err, string_type& __digits) const
      { return do_get(__s, __end, __intl, __f, __err, __digits); }

    protected:
      virtual
      ~money_get() { }

      virtual iter_type
      do_get(iter_type __s, iter_type , bool ,
             ios_base& , ios_base::iostate& ,
             long double& ) const
      { return __s; }

      virtual iter_type
      do_get(iter_type __s, iter_type , bool ,
             ios_base& , ios_base::iostate& ,
             string_type& ) const
      { return __s; }
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;

  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      money_put(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      put(iter_type __s, bool __intl, ios_base& __f,
          char_type __fill, long double __units) const
      { return do_put(__s, __intl, __f, __fill, __units); }

      iter_type
      put(iter_type __s, bool __intl, ios_base& __f,
          char_type __fill, const string_type& __digits) const
      { return do_put(__s, __intl, __f, __fill, __digits); }

    protected:
      virtual
      ~money_put() { }

      virtual iter_type
      do_put(iter_type __s, bool, ios_base& , char_type ,
             long double ) const
      { return __s; }

      virtual iter_type
      do_put(iter_type __s, bool, ios_base& , char_type ,
             const string_type& ) const
      { return __s; }
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;

  struct money_base
  {
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;



    static pattern
    _S_construct_pattern(char __preceeds, char __space, char __posn);
  };

  template<typename _CharT, bool _Intl>
    class moneypunct : public locale::facet, public money_base
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;
      static locale::id id;

    private:
      char_type _M_decimal_point;
      char_type _M_thousands_sep;
      string _M_grouping;
      string_type _M_curr_symbol;
      string_type _M_positive_sign;
      string_type _M_negative_sign;
      int _M_frac_digits;
      pattern _M_pos_format;
      pattern _M_neg_format;

    public:
      explicit
      moneypunct(size_t __refs = 0) : locale::facet(__refs)
      { _M_initialize_moneypunct(); }

      explicit
      moneypunct(__c_locale __cloc, size_t __refs = 0) : locale::facet(__refs)
      { _M_initialize_moneypunct(__cloc); }

      char_type
      decimal_point() const
      { return this->do_decimal_point(); }

      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }

      string
      grouping() const
      { return this->do_grouping(); }

      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }

      string_type
      positive_sign() const
      { return this->do_positive_sign(); }

      string_type
      negative_sign() const
      { return this->do_negative_sign(); }

      int
      frac_digits() const
      { return this->do_frac_digits(); }

      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }

    protected:
      virtual
      ~moneypunct() { }

      virtual char_type
      do_decimal_point() const
      { return _M_decimal_point; }

      virtual char_type
      do_thousands_sep() const
      { return _M_thousands_sep; }

      virtual string
      do_grouping() const
      { return _M_grouping; }

      virtual string_type
      do_curr_symbol() const
      { return _M_curr_symbol; }

      virtual string_type
      do_positive_sign() const
      { return _M_positive_sign; }

      virtual string_type
      do_negative_sign() const
      { return _M_negative_sign; }

      virtual int
      do_frac_digits() const
      { return _M_frac_digits; }

      virtual pattern
      do_pos_format() const
      { return _M_pos_format; }

      virtual pattern
      do_neg_format() const
      { return _M_neg_format; }


      void
      _M_initialize_moneypunct(__c_locale __cloc = __null);
    };

  template<typename _CharT, bool _Intl>
    locale::id moneypunct<_CharT, _Intl>::id;

  template<typename _CharT, bool _Intl>
    const bool moneypunct<_CharT, _Intl>::intl;

  template<typename _CharT, bool _Intl>
    void
    moneypunct<_CharT, _Intl>::_M_initialize_moneypunct(__c_locale )
    {

    }

  template<>
    void
    moneypunct<char>::_M_initialize_moneypunct(__c_locale __cloc);






  template<typename _CharT, bool _Intl>
    class moneypunct_byname : public moneypunct<_CharT, _Intl>
    {
      __c_locale _M_c_locale_moneypunct;
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;

      explicit
      moneypunct_byname(const char* __s, size_t __refs = 0)
      : moneypunct<_CharT, _Intl>(__refs)
      {
        _S_create_c_locale(_M_c_locale_moneypunct, __s);
        _M_initialize_moneypunct(_M_c_locale_moneypunct);
      }

    protected:
      virtual
      ~moneypunct_byname()
      { _S_destroy_c_locale(_M_c_locale_moneypunct); }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;


  struct messages_base
  {
    typedef int catalog;
  };

  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      messages(size_t __refs = 0) : locale::facet(__refs) { }

      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return do_open(__s, __loc); }

      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return do_get(__c,__set,__msgid,__s); }

      void
      close(catalog __c) const
      { return do_close(__c); }

    protected:
      virtual
      ~messages() { }



      virtual catalog
      do_open(const basic_string<char>&, const locale&) const
      { return 0; }

      virtual string_type
      do_get(catalog, int, int , const string_type& __dfault) const
      { return __dfault; }

      virtual void
      do_close(catalog) const { }
    };

  template<typename _CharT>
    locale::id messages<_CharT>::id;

  template<typename _CharT>
    class messages_byname : public messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      messages_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~messages_byname() { }
    };

  template<>
    messages_byname<char>::messages_byname(const char*, size_t __refs);
# 1532 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 3
  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }

  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }

  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }

  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }

  template<typename _CharT>
    inline bool islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }

  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }

  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }

  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }

  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }

  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }

  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }

  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }

  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
}
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.h" 2 3

namespace std
{

  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef ctype<_CharT> __ctype_type;
      typedef ostreambuf_iterator<_CharT, _Traits> __ostreambuf_iter;
      typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
      typedef istreambuf_iterator<_CharT, _Traits> __istreambuf_iter;
      typedef num_get<_CharT, __istreambuf_iter> __numget_type;


    private:
      basic_ostream<_CharT, _Traits>* _M_tie;
      char_type _M_fill;
      iostate _M_exception;

    protected:
      basic_streambuf<_CharT, _Traits>* _M_streambuf;
      iostate _M_streambuf_state;


      const __ctype_type* _M_ios_fctype;

      const __numput_type* _M_fnumput;

      const __numget_type* _M_fnumget;

    public:
      inline const __ctype_type*
      _M_get_fctype_ios(void)
      { return _M_ios_fctype; }

      operator void*() const
      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }

      inline bool
      operator!() const
      { return this->fail(); }

      inline iostate
      rdstate() const
      { return _M_streambuf_state; }

      inline void
      clear(iostate __state = goodbit)
      {
        if (this->rdbuf())
          _M_streambuf_state = __state;
        else
          _M_streambuf_state = __state | badbit;
        if ((this->rdstate() & this->exceptions()))
          __throw_ios_failure("basic_ios::clear(iostate) caused exception");
      }

      inline void
      setstate(iostate __state)
      { this->clear(this->rdstate() | __state); }

      inline bool
      good() const
      { return this->rdstate() == 0; }

      inline bool
      eof() const
      { return (this->rdstate() & eofbit) != 0; }

      inline bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }

      inline bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }

      inline iostate
      exceptions() const
      { return _M_exception; }

      inline void
      exceptions(iostate __except)
      {
        _M_exception = __except;
        this->clear(_M_streambuf_state);
      }


      explicit
      basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base()
      { this->init(__sb); }

      virtual
      ~basic_ios() { }


      inline basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }

      inline basic_ostream<_CharT, _Traits>*
      tie(basic_ostream<_CharT, _Traits>* __tiestr)
      {
        basic_ostream<_CharT, _Traits>* __old = _M_tie;
        _M_tie = __tiestr;
        return __old;
      }

      inline basic_streambuf<_CharT, _Traits>*
      rdbuf() const
      { return _M_streambuf; }

      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);

      basic_ios&
      copyfmt(const basic_ios& __rhs);

      inline char_type
      fill() const
      { return _M_fill; }

      inline char_type
      fill(char_type __ch)
      {
        char_type __old = _M_fill;
        _M_fill = __ch;
        return __old;
      }


      locale
      imbue(const locale& __loc);

      char
      narrow(char_type __c, char __dfault) const;

      char_type
      widen(char __c) const;

    protected:

      basic_ios() : ios_base()
      { }

      void
      init(basic_streambuf<_CharT, _Traits>* __sb);

      bool
      _M_check_facet(const locale::facet* __f)
      {
        bool __ret = false;
        if (__f)
          __ret = true;
        else
          __throw_bad_cast();
        return __ret;
      }

      void
      _M_cache_facets(const locale& __loc);
    };
}



# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.tcc" 1 3
# 33 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.tcc" 3
namespace std
{
  template<typename _CharT, typename _Traits>
    basic_streambuf<_CharT, _Traits>*
    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
    {
      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
      _M_streambuf = __sb;
      this->clear();
      return __old;
    }

  template<typename _CharT, typename _Traits>
    basic_ios<_CharT, _Traits>&
    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
    {




      _Words* __words = (__rhs._M_word_limit <= _S_local_words) ?
        _M_word_array : new _Words[__rhs._M_word_limit];
# 63 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.tcc" 3
      _Callback_list* __cb = __rhs._M_callbacks;
      if (__cb)
        __cb->_M_add_reference();
      _M_call_callbacks(erase_event);
      if (_M_words != _M_word_array)
        delete [] _M_words;
      _M_dispose_callbacks();

      _M_callbacks = __cb;
      for (int __i = 0; __i < __rhs._M_word_limit; ++__i)
        __words[__i] = __rhs._M_words[__i];
      if (_M_words != _M_word_array)
        delete [] _M_words;
      _M_words = __words;
      _M_word_limit = __rhs._M_word_limit;

      this->flags(__rhs.flags());
      this->width(__rhs.width());
      this->precision(__rhs.precision());
      this->tie(__rhs.tie());
      this->fill(__rhs.fill());

      this->exceptions(__rhs.exceptions());

      _M_call_callbacks(copyfmt_event);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    char
    basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
    { return _M_ios_fctype->narrow(__c, __dfault); }

  template<typename _CharT, typename _Traits>
    _CharT
    basic_ios<_CharT, _Traits>::widen(char __c) const
    { return _M_ios_fctype->widen(__c); }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_facets(__loc);
      if (this->rdbuf() != 0)
        this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();
      _M_cache_facets(_M_ios_locale);
      _M_tie = 0;
      _M_fill = this->widen(' ');
      _M_exception = goodbit;
      _M_streambuf = __sb;
      _M_streambuf_state = __sb ? goodbit : badbit;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::_M_cache_facets(const locale& __loc)
    {
      if (has_facet<__ctype_type>(__loc))
        _M_ios_fctype = &use_facet<__ctype_type>(__loc);

      if (has_facet<__numput_type>(__loc))
        _M_fnumput = &use_facet<__numput_type>(__loc);
      if (has_facet<__numget_type>(__loc))
        _M_fnumget = &use_facet<__numget_type>(__loc);
    }
}
# 214 "/usr/local/gcc-3.0.1/include/g++-v3/bits/basic_ios.h" 2 3
# 47 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 2 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ostream.h" 2 3

namespace std
{

  template<typename _CharT, typename _Traits>
    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
    {
    public:


      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef ostreambuf_iterator<_CharT, _Traits> __ostreambuf_iter;
      typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
      typedef ctype<_CharT> __ctype_type;


      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }

      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;



      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&));

      __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&));

      __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&));


      __ostream_type&
      operator<<(long __n);

      __ostream_type&
      operator<<(unsigned long __n);

      __ostream_type&
      operator<<(bool __n);

      __ostream_type&
      operator<<(short __n)
      {
        ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
        if (__fmt & ios_base::oct || __fmt & ios_base::hex)
          return this->operator<<(static_cast<unsigned long>
                                  (static_cast<unsigned short>(__n)));
        else
          return this->operator<<(static_cast<long>(__n));
      }

      __ostream_type&
      operator<<(unsigned short __n)
      { return this->operator<<(static_cast<unsigned long>(__n)); }

      __ostream_type&
      operator<<(int __n)
      {
        ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
        if (__fmt & ios_base::oct || __fmt & ios_base::hex)
          return this->operator<<(static_cast<unsigned long>
                                  (static_cast<unsigned int>(__n)));
        else
          return this->operator<<(static_cast<long>(__n));
      }

      __ostream_type&
      operator<<(unsigned int __n)
      { return this->operator<<(static_cast<unsigned long>(__n)); }
# 135 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ostream.h" 3
      __ostream_type&
      operator<<(double __f);

      __ostream_type&
      operator<<(float __f)
      { return this->operator<<(static_cast<double>(__f)); }

      __ostream_type&
      operator<<(long double __f);

      __ostream_type&
      operator<<(const void* __p);

      __ostream_type&
      operator<<(__streambuf_type* __sb);


      __ostream_type&
      put(char_type __c);

      __ostream_type&
      write(const char_type* __s, streamsize __n);

      __ostream_type&
      flush();


      pos_type
      tellp();

      __ostream_type&
      seekp(pos_type);

      __ostream_type&
      seekp(off_type, ios_base::seekdir);

    private:


      __ostream_type&
      operator=(const __ostream_type&);

      basic_ostream(const __ostream_type&);

    };


  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT,_Traits>& _M_os;

    public:
      explicit
      sentry(basic_ostream<_CharT,_Traits>& __os);

      ~sentry()
      {

        if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
          {

            if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
              _M_os.setstate(ios_base::badbit);
          }
      }

      operator bool()
      { return _M_ok; }
    };

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<class _Traits>
    basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_CharT()); }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }

}




# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ostream.tcc" 1 3
# 32 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ostream.tcc" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_locale.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_locale.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/localefwd.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_locale.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.h" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_locale.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 1 3
# 35 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cerrno.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cerrno.h" 3
# 1 "/usr/include/errno.h" 1 3 4
# 17 "/usr/include/errno.h" 3 4
#pragma ident "@(#)errno.h	1.16	99/07/26 SMI"





# 1 "/usr/include/sys/errno.h" 1 3 4
# 11 "/usr/include/sys/errno.h" 3 4
#pragma ident "@(#)errno.h	1.20	00/02/14 SMI"
# 35 "/usr/include/sys/errno.h" 3 4
extern "C" {
# 192 "/usr/include/sys/errno.h" 3 4
}
# 24 "/usr/include/errno.h" 2 3 4


extern "C" {
# 38 "/usr/include/errno.h" 3 4
extern int *___errno();
# 49 "/usr/include/errno.h" 3 4
}
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cerrno.h" 2 3
# 36 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_clocale.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_clocale.h" 3
# 1 "/usr/include/locale.h" 1 3 4
# 9 "/usr/include/locale.h" 3 4
#pragma ident "@(#)locale.h	1.19	99/08/10 SMI"
# 46 "/usr/include/locale.h" 3 4
# 1 "/usr/include/iso/locale_iso.h" 1 3 4
# 45 "/usr/include/iso/locale_iso.h" 3 4
#pragma ident "@(#)locale_iso.h	1.1	99/08/09 SMI"

# 1 "/usr/include/sys/feature_tests.h" 1 3 4
# 48 "/usr/include/iso/locale_iso.h" 2 3 4


extern "C" {






struct lconv {
        char *decimal_point;
        char *thousands_sep;
        char *grouping;
        char *int_curr_symbol;
        char *currency_symbol;
        char *mon_decimal_point;
        char *mon_thousands_sep;
        char *mon_grouping;
        char *positive_sign;
        char *negative_sign;
        char int_frac_digits;
        char frac_digits;
        char p_cs_precedes;
        char p_sep_by_space;
        char n_cs_precedes;
        char n_sep_by_space;
        char p_sign_posn;
        char n_sign_posn;
};
# 95 "/usr/include/iso/locale_iso.h" 3 4
extern char *setlocale(int, const char *);
extern struct lconv *localeconv(void);
# 107 "/usr/include/iso/locale_iso.h" 3 4
}
# 47 "/usr/include/locale.h" 2 3 4




# 1 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/libintl.h" 1 3 4
# 20 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/libintl.h" 3 4
#pragma ident "@(#)libintl.h	1.12	97/08/20 SMI"

# 1 "/usr/include/sys/isa_defs.h" 1 3 4
# 23 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/libintl.h" 2 3 4


extern "C" {
# 44 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/libintl.h" 3 4
extern char *dcgettext(const char *, const char *, const int);
extern char *dgettext(const char *, const char *);
extern char *gettext(const char *);
extern char *textdomain(const char *);
extern char *bindtextdomain(const char *, const char *);



extern int wdinit(void);
extern int wdchkind(wchar_t);
extern int wdbindf(wchar_t, wchar_t, int);
extern wchar_t *wddelim(wchar_t, wchar_t, int);
extern wchar_t mcfiller(void);
extern int mcwrap(void);
# 78 "/usr/local/gcc-3.0.1/lib/gcc-lib/sparcv9-sun-solaris2.8/3.0.1/include/libintl.h" 3 4
}
# 52 "/usr/include/locale.h" 2 3 4
# 65 "/usr/include/locale.h" 3 4
extern "C" {
# 75 "/usr/include/locale.h" 3 4
}
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_clocale.h" 2 3





namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstdlib.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 1 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 44 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 2 3
# 871 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3
namespace std
{
  enum float_round_style
  {
    round_indeterminate = -1,
    round_toward_zero = 0,
    round_to_nearest = 1,
    round_toward_infinity = 2,
    round_toward_neg_infinity = 3
  };

  enum float_denorm_style
  {
    denorm_indeterminate = -1,
    denorm_absent = 0,
    denorm_present = 1
  };




  template<typename _Tp>
    struct numeric_limits
    {
      static const bool is_specialized = false;

      static _Tp min() throw() { return static_cast<_Tp>(0); }
      static _Tp max() throw() { return static_cast<_Tp>(0); }

      static const int digits = 0;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 0;

      static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
      static _Tp round_error() throw() { return static_cast<_Tp>(0); }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static _Tp infinity() throw() { return static_cast<_Tp>(0); }
      static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
      static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
      static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = false;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::is_specialized;

  template<typename _Tp>
    const int
    numeric_limits<_Tp>::digits;

  template<typename _Tp>
    const int
    numeric_limits<_Tp>::digits10;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::is_signed;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::is_integer;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::is_exact;

  template<typename _Tp>
    const int
    numeric_limits<_Tp>::radix;

  template<typename _Tp>
    const int
    numeric_limits<_Tp>::min_exponent;

  template<typename _Tp>
    const int
    numeric_limits<_Tp>::min_exponent10;

  template<typename _Tp>
    const int
    numeric_limits<_Tp>::max_exponent;

  template<typename _Tp>
    const int
    numeric_limits<_Tp>::max_exponent10;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::has_infinity;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::has_quiet_NaN;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::has_signaling_NaN;

  template<typename _Tp>
    const float_denorm_style
    numeric_limits<_Tp>::has_denorm;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::has_denorm_loss;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::is_iec559;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::is_bounded;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::is_modulo;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::traps;

  template<typename _Tp>
    const bool
    numeric_limits<_Tp>::tinyness_before;

  template<typename _Tp>
    const float_round_style
    numeric_limits<_Tp>::round_style;




  template<>
    struct numeric_limits<bool>
    {
      static const bool is_specialized = true;

      static bool min() throw()
      { return false; }

      static bool max() throw()
      { return true; }

      static const int digits = 8;
      static const int digits10 = 1;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static bool epsilon() throw()
      { return false; }
      static bool round_error() throw()
      { return false; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static bool infinity() throw()
      { return false; }
      static bool quiet_NaN() throw()
      { return false; }
      static bool signaling_NaN() throw()
      { return false; }
      static bool denorm_min() throw()
      { return false; }

      static const bool is_iec559 = true;
      static const bool is_bounded = true;
      static const bool is_modulo = true;




      static const bool traps = true
               || true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };



  template<>
    struct numeric_limits<char>
    {
      static const bool is_specialized = true;

      static char min() throw()
      { return (char)(-127 - 1); }
      static char max() throw()
      { return (char)127; }

      static const int digits = 7;
      static const int digits10 = 7;
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static char epsilon() throw()
      { return char(); }
      static char round_error() throw()
      { return char(); }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static char infinity() throw()
      { return char(); }
      static char quiet_NaN() throw()
      { return char(); }
      static char signaling_NaN() throw()
      { return char(); }
      static char denorm_min() throw()
      { return static_cast<char>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };
# 1141 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3
  template<>
  struct numeric_limits<signed char>
    {
      static const bool is_specialized = true;

      static signed char min() throw()
      { return (-127 - 1); }
      static signed char max() throw()
      { return 127; }

      static const int digits = 7;
      static const int digits10 = 3;
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static signed char epsilon() throw()
      { return 0; }
      static signed char round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static signed char infinity() throw()
      { return static_cast<signed char>(0); }
      static signed char quiet_NaN() throw()
      { return static_cast<signed char>(0); }
      static signed char signaling_NaN() throw()
      { return static_cast<signed char>(0); }
      static signed char denorm_min() throw()
      { return static_cast<signed char>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };







  template<>
    struct numeric_limits<unsigned char>
    {
      static const bool is_specialized = true;

      static unsigned char min() throw()
      { return 0; }
      static unsigned char max() throw()
      { return (127 * 2 + 1); }

      static const int digits = 8;
      static const int digits10 = 3;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned char epsilon() throw()
      { return 0; }
      static unsigned char round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned char infinity() throw()
      { return static_cast<unsigned char>(0); }
      static unsigned char quiet_NaN() throw()
      { return static_cast<unsigned char>(0); }
      static unsigned char signaling_NaN() throw()
      { return static_cast<unsigned char>(0); }
      static unsigned char denorm_min() throw()
      { return static_cast<unsigned char>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };






  template<>
    struct numeric_limits<wchar_t>
    {
      static const bool is_specialized = true;

      static wchar_t min() throw()
      { return (wchar_t)(-2147483647L - 1); }
      static wchar_t max() throw()
      { return (wchar_t)2147483647L; }

      static const int digits = 31;
      static const int digits10 = 10;
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static wchar_t epsilon() throw()
      { return 0; }
      static wchar_t round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static wchar_t infinity() throw()
      { return wchar_t(); }
      static wchar_t quiet_NaN() throw()
      { return wchar_t(); }
      static wchar_t signaling_NaN() throw()
      { return wchar_t(); }
      static wchar_t denorm_min() throw()
      { return wchar_t(); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };
# 1309 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3
  template<>
    struct numeric_limits<short>
    {
      static const bool is_specialized = true;

      static short min() throw()
      { return (-32767 - 1); }
      static short max() throw()
      { return 32767; }

      static const int digits = 15;
      static const int digits10 = 5;
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static short epsilon() throw()
      { return 0; }
      static short round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static short infinity() throw()
      { return short(); }
      static short quiet_NaN() throw()
      { return short(); }
      static short signaling_NaN() throw()
      { return short(); }
      static short denorm_min() throw()
      { return short(); }

      static const bool is_iec559 = true;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };







  template<>
    struct numeric_limits<unsigned short>
    {
      static const bool is_specialized = true;

      static unsigned short min() throw()
      { return 0; }
      static unsigned short max() throw()
      { return (32767 * 2 + 1); }

      static const int digits = 16;
      static const int digits10 = 5;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned short epsilon() throw()
      { return 0; }
      static unsigned short round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned short infinity() throw()
      { return static_cast<unsigned short>(0); }
      static unsigned short quiet_NaN() throw()
      { return static_cast<unsigned short>(0); }
      static unsigned short signaling_NaN() throw()
      { return static_cast<unsigned short>(0); }
      static unsigned short denorm_min() throw()
      { return static_cast<unsigned short>(0); }

      static const bool is_iec559 = true;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };






  template<>
    struct numeric_limits<int>
    {
      static const bool is_specialized = true;

      static int min() throw()
      { return (int)(-2147483647L - 1); }
      static int max() throw()
      { return (int)2147483647L; }

      static const int digits = 31;
      static const int digits10 = 10;
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static int epsilon() throw()
      { return 0; }
      static int round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static int infinity() throw()
      { return static_cast<int>(0); }
      static int quiet_NaN() throw()
      { return static_cast<int>(0); }
      static int signaling_NaN() throw()
      { return static_cast<int>(0); }
      static int denorm_min() throw()
      { return static_cast<int>(0); }

      static const bool is_iec559 = true;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };







  template<>
    struct numeric_limits<unsigned int>
    {
      static const bool is_specialized = true;

      static unsigned int min() throw()
      { return 0; }
          static unsigned int max() throw()
      { return (unsigned)(2147483647L * 2U + 1); }

      static const int digits = 32;
      static const int digits10 = 10;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned int epsilon() throw()
      { return 0; }
      static unsigned int round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned int infinity() throw()
      { return static_cast<unsigned int>(0); }
      static unsigned int quiet_NaN() throw()
      { return static_cast<unsigned int>(0); }
      static unsigned int signaling_NaN() throw()
      { return static_cast<unsigned int>(0); }
      static unsigned int denorm_min() throw()
      { return static_cast<unsigned int>(0); }

      static const bool is_iec559 = true;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };






  template<>
    struct numeric_limits<long>
    {
      static const bool is_specialized = true;

      static long min() throw()
      { return (long)(-9223372036854775807LL - 1); }
      static long max() throw()
      { return (long)9223372036854775807LL; }

      static const int digits = 63;
      static const int digits10 = 19;
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static long epsilon() throw()
      { return 0; }
      static long round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static long infinity() throw()
      { return static_cast<long>(0); }
      static long quiet_NaN() throw()
      { return static_cast<long>(0); }
      static long signaling_NaN() throw()
      { return static_cast<long>(0); }
      static long denorm_min() throw()
      { return static_cast<long>(0); }

      static const bool is_iec559 = true;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };







  template<>
    struct numeric_limits<unsigned long>
    {
      static const bool is_specialized = true;

      static unsigned long min() throw()
      { return 0; }
      static unsigned long max() throw()
      { return (unsigned long)(9223372036854775807LL * 2ULL + 1); }

      static const int digits = 64;
      static const int digits10 = 19;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static unsigned long epsilon() throw()
      { return 0; }
      static unsigned long round_error() throw()
      { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned long infinity() throw()
      { return static_cast<unsigned long>(0); }
      static unsigned long quiet_NaN() throw()
      { return static_cast<unsigned long>(0); }
      static unsigned long signaling_NaN() throw()
      { return static_cast<unsigned long>(0); }
      static unsigned long denorm_min() throw()
      { return static_cast<unsigned long>(0); }

      static const bool is_iec559 = true;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };
# 1758 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3
  template<>
    struct numeric_limits<float>
    {
      static const bool is_specialized = true;

      static float min() throw()
      { return 1.17549435e-38F; }
      static float max() throw()
      { return 3.40282347e+38F; }

      static const int digits = 24;
      static const int digits10 = 6;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      static float epsilon() throw()
      { return 2; }
      static float round_error() throw()
      { return 1.0F; }

      static const int min_exponent = -125;
      static const int min_exponent10 = -37;
      static const int max_exponent = 128;
      static const int max_exponent10 = 38;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;

      static float infinity() throw()
      { return 0.0F; }
      static float quiet_NaN() throw()
      { return 0.0F; }
      static float signaling_NaN() throw()
      { return 0.0F; }
      static float denorm_min() throw()
      { return 0.0F; }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };
# 1834 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3
  template<>
    struct numeric_limits<double>
    {
      static const bool is_specialized = true;

      static double min() throw()
      { return 2.2250738585072014e-308; }
      static double max() throw()
      { return 1.7976931348623157e+308; }

      static const int digits = 53;
      static const int digits10 = 15;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      static double epsilon() throw()
      { return 2.2204460492503131e-16; }
      static double round_error() throw()
      { return 1.0; }

      static const int min_exponent = -1021;
      static const int min_exponent10 = -307;
      static const int max_exponent = 1024;
      static const int max_exponent10 = 308;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm =
              denorm_absent;;
      static const bool has_denorm_loss = false;;

      static double infinity() throw()
      { return 0.0; }
      static double quiet_NaN() throw()
      { return 0.0; }
      static double signaling_NaN() throw()
      { return 0.0; }
      static double denorm_min() throw()
      { return 0.0; }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style =
              round_toward_zero;
    };
# 1913 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3
  template<>
    struct numeric_limits<long double>
    {
      static const bool is_specialized = true;

      static long double min() throw()
      { return 3.362103143112093506262677817321752603E-4932L; }
      static long double max() throw()
      { return 1.189731495357231765085759326628007016E+4932L; }

      static const int digits = 113;
      static const int digits10 = 33;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 2;
      static long double epsilon() throw()
      { return 1.925929944387235853055977942584927319E-34L; }
      static long double round_error() throw()
      { return 1.0L; }

      static const int min_exponent = -16381;
      static const int min_exponent10 = -4931;
      static const int max_exponent = 16384;
      static const int max_exponent10 = 4932;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN =
                false;
      static const float_denorm_style has_denorm =
                denorm_absent;
      static const bool has_denorm_loss =
                false;

      static long double infinity() throw()
      { return 0.0L; }
      static long double quiet_NaN() throw()
      { return 0.0L; }
      static long double signaling_NaN() throw()
      { return 0.0L; }
      static long double denorm_min() throw()
      { return 0.0L; }

      static const bool is_iec559 = false;
      static const bool is_bounded = false;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style =
                    round_toward_zero;
    };
# 1993 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 3
}
# 39 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_memory.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/sbuf_iter.h" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cctype.h" 1 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/typeinfo" 1 3
# 37 "/usr/local/gcc-3.0.1/include/g++-v3/typeinfo" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/exception" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/typeinfo" 2 3

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 54 "/usr/local/gcc-3.0.1/include/g++-v3/typeinfo" 3
namespace std
{



  class type_info
  {
  public:




    virtual ~type_info();

  private:

    type_info& operator=(const type_info&);
    type_info(const type_info&);

  protected:
    const char *__name;

  protected:
    explicit type_info(const char *__n): __name(__n) { }

  public:



    const char* name() const
    { return __name; }
# 97 "/usr/local/gcc-3.0.1/include/g++-v3/typeinfo" 3
    bool before(const type_info& __arg) const
    { return __name < __arg.__name; }
    bool operator==(const type_info& __arg) const
    { return __name == __arg.__name; }

    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }


  public:

    virtual bool __is_pointer_p() const;

    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
                            unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
                             void **__obj_ptr) const;
  };



  class bad_cast : public exception
  {
  public:
    bad_cast() throw() { }
    virtual ~bad_cast() throw();
  };


  class bad_typeid : public exception
  {
  public:
    bad_typeid () throw() { }
    virtual ~bad_typeid () throw();
  };
}

}
# 43 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_vector.h" 1 3
# 44 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 2 3


namespace std
{
  template<typename _Facet>
    locale
    locale::combine(const locale& __other)
    {
      locale __copy(*this);
      __copy._M_impl->_M_replace_facet(__other._M_impl, &_Facet::id);
      return __copy;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
                       const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type* __fcoll = &use_facet<__collate_type>(*this);
      return (__fcoll->compare(__s1.data(), __s1.data() + __s1.length(),
                               __s2.data(), __s2.data() + __s2.length()) < 0);
    }

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc)
    {
      typedef locale::_Impl::__vec_facet __vec_facet;
      size_t __i = _Facet::id._M_index;
      __vec_facet* __facet = __loc._M_impl->_M_facets;
      const locale::facet* __fp = (*__facet)[__i];
      if (__fp == 0 || __i >= __facet->size())
        __throw_bad_cast();
      return static_cast<const _Facet&>(*__fp);
    }

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw()
    {
      typedef locale::_Impl::__vec_facet __vec_facet;
      size_t __i = _Facet::id._M_index;
      __vec_facet* __facet = __loc._M_impl->_M_facets;
      return (__i < __facet->size() && (*__facet)[__i] != 0);
    }







  template<typename _InIter, typename _CharT>
    _InIter
    __match_parallel(_InIter __s, _InIter __end, int __ntargs,
                     const basic_string<_CharT>* __targets,
                     int* __matches, int& __remain, bool& __eof)
    {
      typedef basic_string<_CharT> __string_type;
      __eof = false;
      for (int __ti = 0; __ti < __ntargs; ++__ti)
        __matches[__ti] = __ti;
      __remain = __ntargs;
      size_t __pos = 0;
      do
        {
          int __ti = 0;
          while (__ti < __remain && __pos == __targets[__matches[__ti]].size())
            ++__ti;
          if (__ti == __remain)
            {
              if (__pos == 0) __remain = 0;
              return __s;
            }
          if (__s == __end)
            __eof = true;
          bool __matched = false;
          for (int __ti2 = 0; __ti2 < __remain; )
            {
              const __string_type& __target = __targets[__matches[__ti2]];
              if (__pos < __target.size())
                {
                  if (__eof || __target[__pos] != *__s)
                    {
                      __matches[__ti2] = __matches[--__remain];
                      continue;
                    }
                  __matched = true;
                }
              ++__ti2;
            }
          if (__matched)
            {
              ++__s;
              ++__pos;
            }
          for (int __ti3 = 0; __ti3 < __remain;)
            {
              if (__pos > __targets[__matches[__ti3]].size())
                {
                  __matches[__ti3] = __matches[--__remain];
                  continue;
                }
              ++__ti3;
            }
        }
      while (__remain);
      return __s;
    }

  template<typename _CharT>
    _Format_cache<_CharT>::_Format_cache()
    : _M_valid(true), _M_use_grouping(false)
    { }

  template<>
    _Format_cache<char>::_Format_cache();

  template<>
    _Format_cache<wchar_t>::_Format_cache();

  template<typename _CharT>
    void
    _Format_cache<_CharT>::_M_populate(ios_base& __io)
    {
      locale __loc = __io.getloc ();
      numpunct<_CharT> const& __np = use_facet<numpunct<_CharT> >(__loc);
      _M_truename = __np.truename();
      _M_falsename = __np.falsename();
      _M_thousands_sep = __np.thousands_sep();
      _M_decimal_point = __np.decimal_point();
      _M_grouping = __np.grouping();
      _M_use_grouping = _M_grouping.size() != 0 && _M_grouping.data()[0] != 0;
      _M_valid = true;
    }



  template<typename _CharT>
    void
    _Format_cache<_CharT>::
    _S_callback(ios_base::event __ev, ios_base& __ios, int __ix) throw()
    {
      void*& __p = __ios.pword(__ix);
      switch (__ev)
        {
        case ios_base::erase_event:
          delete static_cast<_Format_cache<_CharT>*>(__p);
          __p = 0;
          break;
        case ios_base::copyfmt_event:

          try
            { __p = new _Format_cache<_CharT>; }
          catch(...)
            { }
          break;
        case ios_base::imbue_event:
          static_cast<_Format_cache<_CharT>*>(__p)->_M_valid = false;
          break;
        }
    }

  template<typename _CharT>
    _Format_cache<_CharT>*
    _Format_cache<_CharT>::_S_get(ios_base& __ios)
    {
      if (!_S_pword_ix)
        _S_pword_ix = ios_base::xalloc();
      void*& __p = __ios.pword(_S_pword_ix);


      if (__p == 0)
        {
          auto_ptr<_Format_cache<_CharT> > __ap(new _Format_cache<_CharT>);
          __ios.register_callback(&_Format_cache<_CharT>::_S_callback,
                                  _S_pword_ix);
          __p = __ap.release();
        }
      _Format_cache<_CharT>* __ncp = static_cast<_Format_cache<_CharT>*>(__p);
      if (!__ncp->_M_valid)
        __ncp->_M_populate(__ios);

      return __ncp;
    }
# 250 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    void
    num_get<_CharT, _InIter>::
    _M_extract(_InIter , _InIter , ios_base& ,
               ios_base::iostate& , char* ,
               int& , bool ) const
    {

    }

  template<>
    void
    num_get<char, istreambuf_iterator<char> >::
    _M_extract(istreambuf_iterator<char> __beg,
               istreambuf_iterator<char> __end, ios_base& __io,
               ios_base::iostate& __err, char* __xtrc, int& __base,
               bool __fp) const;



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, bool& __v) const
    {

      if (!(__io.flags() & ios_base::boolalpha))
        {






          char __xtrc[32] = {'\0'};
          int __base;
          _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


          char* __sanity;
          (*(___errno())) = 0;
          long __l = strtol(__xtrc, &__sanity, __base);
          if (!(__err & ios_base::failbit)
              && __l <= 1
              && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0)
            __v = __l;
          else
            __err |= ios_base::failbit;
        }


      else
        {
          typedef _Format_cache<char_type> __fcache_type;
          __fcache_type* __fmt = __fcache_type::_S_get(__io);
          const char_type* __true = __fmt->_M_truename.c_str();
          const char_type* __false = __fmt->_M_falsename.c_str();
          const size_t __truelen = __traits_type::length(__true) - 1;
          const size_t __falselen = __traits_type::length(__false) - 1;

          for (size_t __pos = 0; __beg != __end; ++__pos)
            {
              char_type __c = *__beg++;
              bool __testf = __c == __false[__pos];
              bool __testt = __c == __true[__pos];
              if (!(__testf || __testt))
                {
                  __err |= ios_base::failbit;
                  break;
                }
              else if (__testf && __pos == __falselen)
                {
                  __v = 0;
                  break;
                }
              else if (__testt && __pos == __truelen)
                {
                  __v = 1;
                  break;
                }
            }
          if (__beg == __end)
            __err |= ios_base::eofbit;
        }

      return __beg;
    }



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, short& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*(___errno())) = 0;
      long __l = strtol(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0
          && __l >= (-32767-1) && __l <= 32767)
        __v = static_cast<short>(__l);
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, int& __v) const
    {



      char __xtrc[32] = {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*(___errno())) = 0;
      long __l = strtol(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0
          && __l >= (-2147483647 -1) && __l <= 2147483647)
        __v = static_cast<int>(__l);
      else
        __err |= ios_base::failbit;

      return __beg;
    }


  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*(___errno())) = 0;
      long __l = strtol(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0)
        __v = __l;
      else
        __err |= ios_base::failbit;

      return __beg;
    }
# 450 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, unsigned short& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*(___errno())) = 0;
      unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0
          && __ul <= 65535)
        __v = static_cast<unsigned short>(__ul);
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, unsigned int& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*(___errno())) = 0;
      unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0
          && __ul <= (2147483647 * 2U + 1))
        __v = static_cast<unsigned int>(__ul);
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, unsigned long& __v) const
    {



      char __xtrc[32] = {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*(___errno())) = 0;
      unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0)
        __v = __ul;
      else
        __err |= ios_base::failbit;

      return __beg;
    }
# 558 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, float& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, true);


      char* __sanity;
      (*(___errno())) = 0;



      float __f = static_cast<float>(strtod(__xtrc, &__sanity));

      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0)
        __v = __f;
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, double& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, true);


      char* __sanity;
      (*(___errno())) = 0;
      double __d = strtod(__xtrc, &__sanity);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0)
        __v = __d;
      else
        __err |= ios_base::failbit;

      return __beg;
    }
# 641 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long double& __v) const
    {

      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, true);


      ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
      const char* __conv;
      if (__basefield == ios_base::oct)
        __conv = "%Lo";
      else if (__basefield == ios_base::hex)
        __conv = "%LX";
      else if (__basefield == 0)
        __conv = "%Li";
      else
        __conv = "%Lg";


      long double __ld;
      int __p = sscanf(__xtrc, __conv, &__ld);
      if (__p
          && static_cast<typename __traits_type::int_type>(__p)
        != __traits_type::eof())
        __v = __ld;
      else
        __err |= ios_base::failbit;

      return __beg;
    }


  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      fmtflags __fmt = __io.flags();
      fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
                             | ios_base::uppercase | ios_base::internal);
      __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));




      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*(___errno())) = 0;
      void* __vp = reinterpret_cast<void*>(strtoul(__xtrc, &__sanity, __base));
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*(___errno())) == 0)
        __v = __vp;
      else
        __err |= ios_base::failbit;


      __io.flags(__fmt);
      return __beg;
    }


  template <typename _CharT, typename _OutIter>
    inline _OutIter
    __pad(_OutIter __s, _CharT __fill, int __padding);

  template <typename _CharT, typename _RaIter>
    _RaIter
    __pad(_RaIter __s, _CharT __fill, int __padding,
          random_access_iterator_tag)
    {
      fill_n(__s, __fill);
      return __s + __padding;
    }

  template <typename _CharT, typename _OutIter, typename _Tag>
    _OutIter
    __pad(_OutIter __s, _CharT __fill, int __padding, _Tag)
    {
      while (--__padding >= 0) { *__s = __fill; ++__s; }
      return __s;
    }

  template <typename _CharT, typename _OutIter>
    inline _OutIter
    __pad(_OutIter __s, _CharT __fill, int __padding)
    {
      return __pad(__s, __fill, __padding,
                   typename iterator_traits<_OutIter>::iterator_category());
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    __pad_numeric(_OutIter __s, ios_base::fmtflags ,
                  _CharT , int ,
                  _CharT const* , _CharT const* ,
                  _CharT const* )
  {

      return __s;
    }


  template <typename _CharT>
    ostreambuf_iterator<_CharT>
    __pad_numeric(ostreambuf_iterator<_CharT> __s, ios_base::fmtflags __flags,
                  _CharT __fill, int __width, _CharT const* __first,
                  _CharT const* __middle, _CharT const* __last)
    {
      typedef ostreambuf_iterator<_CharT> __out_iter;
      int __padding = __width - (__last - __first);
      if (__padding < 0)
        __padding = 0;
      ios_base::fmtflags __aflags = __flags & ios_base::adjustfield;
      bool __testfield = __padding == 0 || __aflags == ios_base::left
                         || __aflags == ios_base::internal;


      if (__first != __middle)
        {
          if (!__testfield)
            {
              __pad(__s, __fill, __padding);
              __padding = 0;
            }
          copy(__first, __middle, __s);
        }
      __out_iter __s2 = __s;

      if (__padding && __aflags != ios_base::left)
        {
          __pad(__s2, __fill, __padding);
          __padding = 0;
        }
      __out_iter __s3 = copy(__middle, __last, __s2);
      if (__padding)
        __pad(__s3, __fill, __padding);
      return __s3;
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
    {
      const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io);
      ios_base::fmtflags __flags = __io.flags();

      if ((__flags & ios_base::boolalpha) == 0)
        {
          unsigned long __uv = __v;
          return __output_integer(__s, __io, __fill, false, __uv);
        }
      else
        {
          const char_type* __first;
          const char_type* __last;
          if (__v)
            {
              __first = __fmt->_M_truename.data();
              __last = __first + __fmt->_M_truename.size();
            }
          else
            {
              __first = __fmt->_M_falsename.data();
              __last = __first + __fmt->_M_falsename.size();
            }
          copy(__first, __last, __s);
        }
      return __s;
    }





  template <typename _CharT>
    _CharT*
    __group_digits(_CharT* __s, _CharT __grsep, char const* __grouping,
                    char const* __grend, _CharT const* __first,
                    _CharT const* __last)
    {
      if (__last - __first > *__grouping)
        {
          __s = __group_digits(__s, __grsep,
              (__grouping + 1 == __grend ? __grouping : __grouping + 1),
              __grend, __first, __last - *__grouping);
          __first = __last - *__grouping;
          *__s++ = __grsep;
        }
      do
        {
          *__s++ = *__first++;
        }
      while (__first != __last);
      return __s;
    }

  template <typename _CharT, typename _OutIter, typename _ValueT>
    _OutIter
    __output_integer(_OutIter __s, ios_base& __io, _CharT __fill, bool __neg,
              _ValueT __v)
    {

      const long _M_room = numeric_limits<_ValueT>::digits10 * 2 + 4;
      _CharT __digits[_M_room];
      _CharT* __front = __digits + _M_room;
      ios_base::fmtflags __flags = __io.flags();
      const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io);
      char const* __table = __fmt->_S_literals + __fmt->_S_digits;

      ios_base::fmtflags __basefield = (__flags & __io.basefield);
      _CharT* __sign_end = __front;
      if (__basefield == ios_base::hex)
        {
          if (__flags & ios_base::uppercase)
            __table += 16;
          do
            *--__front = __table[__v & 15];
          while ((__v >>= 4) != 0);
          __sign_end = __front;
          if (__flags & ios_base::showbase)
            {
              *--__front = __fmt->_S_literals[__fmt->_S_x +
                       ((__flags & ios_base::uppercase) ? 1 : 0)];
              *--__front = __table[0];
            }
        }
      else if (__basefield == ios_base::oct)
        {
          do
            *--__front = __table[__v & 7];
          while ((__v >>= 3) != 0);
          if (__flags & ios_base::showbase
              && static_cast<char>(*__front) != __table[0])
            *--__front = __table[0];
          __sign_end = __front;
        }
      else
        {

          do
            *--__front = __table[__v % 10];
          while ((__v /= 10) != 0);
          __sign_end = __front;

          if (__neg || (__flags & ios_base::showpos))
            *--__front = __fmt->_S_literals[__fmt->_S_plus - __neg];
        }


      if (!__fmt->_M_use_grouping && !__io.width())
        return copy(__front, __digits + _M_room, __s);

      if (!__fmt->_M_use_grouping)
        return __pad_numeric(__s, __flags, __fill, __io.width(0),
                             __front, __sign_end, __digits + _M_room);

      _CharT* __p = __digits;
      while (__front < __sign_end)
        *__p++ = *__front++;
      const char* __gr = __fmt->_M_grouping.data();
      __front = __group_digits(__p, __fmt->_M_thousands_sep, __gr,
        __gr + __fmt->_M_grouping.size(), __sign_end, __digits + _M_room);
      return __pad_numeric(__s, __flags, __fill, __io.width(0),
                           __digits, __p, __front);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
    {
      unsigned long __uv = __v;
      bool __neg = false;
      if (__v < 0)
        {
          __neg = true;
          __uv = -__uv;
        }
      return __output_integer(__s, __io, __fill, __neg, __uv);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           unsigned long __v) const
    { return __output_integer(__s, __io, __fill, false, __v); }
# 967 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits, typename _OutIter>
    _OutIter
    __output_float(_OutIter __s, ios_base& __io, _CharT __fill,
                    const char* __sptr, size_t __slen)
    {

      return __s;
    }


  template<typename _CharT, typename _Traits>
    ostreambuf_iterator<_CharT, _Traits>
    __output_float(ostreambuf_iterator<_CharT, _Traits> __s, ios_base& __io,
                   _CharT __fill, const char* __sptr, size_t __slen)
    {
      size_t __padding = __io.width() > streamsize(__slen) ?
                         __io.width() -__slen : 0;
      locale __loc = __io.getloc();
      ctype<_CharT> const& __ct = use_facet<ctype<_CharT> >(__loc);
      ios_base::fmtflags __adjfield = __io.flags() & ios_base::adjustfield;
      const char* const __eptr = __sptr + __slen;

      if (__adjfield == ios_base::internal)
       {

         if (__sptr < __eptr && (*__sptr == '+' || *__sptr == '-'))
           {
             __s = __ct.widen(*__sptr);
             ++__s;
             ++__sptr;
           }
         __s = __pad(__s, __fill, __padding);
         __padding = 0;
       }
      else if (__adjfield != ios_base::left)
        {
          __s = __pad(__s, __fill, __padding);
          __padding = 0;
        }

      char __decimal_point = *(localeconv()->decimal_point);
      const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io);
      for (; __sptr != __eptr; ++__s, ++__sptr)
       {

         if (*__sptr == __decimal_point)
           __s = __fmt->_M_decimal_point;

         else
           __s = __ct.widen(*__sptr);
       }

      if (__padding)
        __pad(__s, __fill, __padding);
      __io.width(0);
      return __s;
    }

  bool
  __build_float_format(ios_base& __io, char* __fptr, char __modifier,
                       streamsize __prec);

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    {
      const streamsize __max_prec = numeric_limits<double>::digits10 + 3;
      streamsize __prec = __io.precision();

      if (__prec > __max_prec)
        __prec = __max_prec;

      char __sbuf[__max_prec * 2];
      size_t __slen;

      char __fbuf[16];
      if (__build_float_format(__io, __fbuf, 0, __prec))
        __slen = sprintf(__sbuf, __fbuf, __prec, __v);
      else
        __slen = sprintf(__sbuf, __fbuf, __v);

      return __output_float(__s, __io, __fill, __sbuf, __slen);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           long double __v) const
    {
      const streamsize __max_prec = numeric_limits<long double>::digits10 + 3;
      streamsize __prec = __io.precision();

      if (__prec > __max_prec)
        __prec = __max_prec;

      char __sbuf[__max_prec * 2];
      size_t __slen;

      char __fbuf[16];

      if (__build_float_format(__io, __fbuf, 'L', __prec))
        __slen = sprintf(__sbuf, __fbuf, __prec, __v);
      else
        __slen = sprintf(__sbuf, __fbuf, __v);

      return __output_float(__s, __io, __fill, __sbuf, __slen);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           const void* __v) const
    {
      typedef ios_base::fmtflags fmtflags;
      fmtflags __fmt = __io.flags();
      fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
                             | ios_base::uppercase | ios_base::internal);
      __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));
      try {
        _OutIter __s2 = __output_integer(__s, __io, __fill, false,
                                  reinterpret_cast<unsigned long>(__v));
        __io.flags(__fmt);
        return __s2;
      }
      catch (...) {
        __io.flags(__fmt);
        throw;
      }
    }





  template<typename _CharT, typename _Dummy = int>
    struct _Weekdaynames;

  template<typename _Dummy>
    struct _Weekdaynames<char, _Dummy>
    { static const char* const _S_names[14]; };

  template<typename _Dummy>
    const char* const
    _Weekdaynames<char, _Dummy>::_S_names[14] =
    {
      "Sun", "Sunday",
      "Mon", "Monday", "Tue", "Tuesday", "Wed", "Wednesday",
      "Thu", "Thursday", "Fri", "Friday", "Sat", "Saturday"
    };
# 1135 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Dummy = int>
    struct _Monthnames;

  template<typename _Dummy>
    struct _Monthnames<char,_Dummy>
    { static const char* const _S_names[24]; };

  template<typename _Dummy>
    const char* const
    _Monthnames<char,_Dummy>::_S_names[24] =
    {
      "Jan", "January", "Feb", "February", "Mar", "March",
      "Apr", "April", "May", "May", "Jun", "June",
      "Jul", "July", "Aug", "August", "Sep", "September",
      "Oct", "October", "Nov", "November", "Dec", "December"
    };
# 1168 "/usr/local/gcc-3.0.1/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __s, iter_type __end,
                   ios_base& __io, ios_base::iostate& __err, tm* __t) const
    {
      if (!_M_daynames)
        {
          _M_daynames = new basic_string<_CharT>[14];
          for (int __i = 0; __i < 14; ++__i)
            _M_daynames[__i] = _Weekdaynames<_CharT>::_S_names[__i];
        }
      bool __at_eof = false;
      int __remain = 0;
      int __matches[14];
      iter_type __out = __match_parallel(__s, __end, 14, _M_daynames,
                                         __matches, __remain, __at_eof);
      __err = ios_base::iostate(0);
      if (__at_eof) __err |= __io.eofbit;
      if (__remain == 1 ||
          __remain == 2 && (__matches[0]>>1) == (__matches[1]>>1))
        __t->tm_wday = (__matches[0]>>1);
      else
        __err |= __io.failbit;
      return __out;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __s, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __t) const
    {
      if (!_M_monthnames)
        {
          _M_monthnames = new basic_string<_CharT>[24];
          for (int __i = 0; __i < 24; ++__i)
            _M_monthnames[__i] = _Monthnames<_CharT>::_S_names[__i];
        }
      bool __at_eof = false;
      int __remain = 0;
      int __matches[24];
      iter_type __out = __match_parallel( __s, __end, 24, _M_monthnames,
                                          __matches, __remain, __at_eof);
      __err = ios_base::iostate(0);
      if (__at_eof) __err |= __io.eofbit;
      if (__remain == 1 ||
          __remain == 2 && (__matches[0]>>1) == (__matches[1]>>1))
        __t->tm_mon = (__matches[0]>>1);
      else
        __err |= __io.failbit;
      return __out;
    }
}
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_locale.h" 2 3
# 33 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ostream.tcc" 2 3

namespace std
{
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT,_Traits>& __os)
    : _M_ok(__os.good()), _M_os(__os)
    {

      if (_M_ok && __os.tie())
        __os.tie()->flush();
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ostream_type& (*__pf)(__ostream_type&))
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            { __pf(*this); }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ios_type& (*__pf)(__ios_type&))
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            { __pf(*this); }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(ios_base& (*__pf)(ios_base&))
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            { __pf(*this); }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::operator<<(bool __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            {
              if (_M_check_facet(_M_fnumput))
                if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
                  this->setstate(ios_base::badbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::operator<<(long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            {
              char_type __c = this->fill();
              ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
              if (_M_check_facet(_M_fnumput))
                {
                  bool __b = false;
                  if (__fmt & ios_base::oct || __fmt & ios_base::hex)
                    {
                      unsigned long __l = static_cast<unsigned long>(__n);
                      __b = _M_fnumput->put(*this, *this, __c, __l).failed();
                    }
                  else
                    __b = _M_fnumput->put(*this, *this, __c, __n).failed();
                  if (__b)
                    this->setstate(ios_base::badbit);
                }
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            {
              if (_M_check_facet(_M_fnumput))
                if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
                  this->setstate(ios_base::badbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }
# 264 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ostream.tcc" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::operator<<(double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            {
              if (_M_check_facet(_M_fnumput))
                if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
                  this->setstate(ios_base::badbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::operator<<(long double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            {
              if (_M_check_facet(_M_fnumput))
                if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
                  this->setstate(ios_base::badbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          try
            {
              if (_M_check_facet(_M_fnumput))
                if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
                  this->setstate(ios_base::badbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::operator<<(__streambuf_type* __sbin)
    {
      streamsize __xtrct = 0;
      __streambuf_type* __sbout = this->rdbuf();
      sentry __cerb(*this);
      if (__sbin && __cerb)
        __xtrct = __copy_streambufs(*this, __sbin, __sbout);
      if (!__sbin || !__xtrct)
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::put(char_type __c)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          int_type __put = rdbuf()->sputc(__c);
          if (__put != traits_type::to_int_type(__c))
            this->setstate(ios_base::badbit);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::write(const _CharT* __s, streamsize __n)
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          streamsize __put = this->rdbuf()->sputn(__s, __n);
          if ( __put != __n)
            this->setstate(ios_base::badbit);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::flush()
    {
      sentry __cerb(*this);
      if (__cerb)
        {
          if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
            this->setstate(ios_base::badbit);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::tellp()
    {
      pos_type __ret = pos_type(-1);
      bool __testok = this->fail() != true;

      if (__testok)
        __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
      return __ret;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
    {
      bool __testok = this->fail() != true;

      if (__testok)
        {


          pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::out);


          if (__err == pos_type(off_type(-1)))
            this->setstate(failbit);

        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __d)
    {
      bool __testok = this->fail() != true;

      if (__testok)
        {


          pos_type __err = this->rdbuf()->pubseekoff(__off, __d,
                                                     ios_base::out);


          if (__err == pos_type(off_type(-1)))
            this->setstate(failbit);
        }

      return *this;
    }
# 457 "/usr/local/gcc-3.0.1/include/g++-v3/bits/ostream.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad_char(basic_ios<_CharT, _Traits>& __ios,
               _CharT* __news, const _CharT* __olds,
               const streamsize __newlen, const streamsize __oldlen)
    {
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;

      int_type __plen = static_cast<size_t>(__newlen - __oldlen);
      char_type* __pads = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __plen));
      traits_type::assign(__pads, __plen, __ios.fill());

      char_type* __beg;
      char_type* __end;
      size_t __mod = 0;
      size_t __beglen;
      ios_base::fmtflags __fmt = __ios.flags() & ios_base::adjustfield;

      if (__fmt == ios_base::left)
        {

          __beg = const_cast<char_type*>(__olds);
          __beglen = __oldlen;
          __end = __pads;
        }
      else if (__fmt == ios_base::internal)
        {



          typedef _Format_cache<_CharT> __cache_type;
          __cache_type const* __fmt = __cache_type::_S_get(__ios);
          const char_type* __minus = traits_type::find(__olds, __oldlen,
                                                       __fmt->_S_minus);
          const char_type* __plus = traits_type::find(__olds, __oldlen,
                                                      __fmt->_S_plus);
          bool __testsign = __minus || __plus;
          bool __testhex = __olds[0] == '0'
                           && (__olds[1] == 'x' || __olds[1] == 'X');

          if (__testhex)
            {
              __news[0] = __olds[0];
              __news[1] = __olds[1];
              __mod += 2;
              __beg = const_cast<char_type*>(__olds + __mod);
              __beglen = __oldlen - __mod;
              __end = __pads;
            }
          else if (__testsign)
            {
              __mod += __plen;
              const char_type* __sign = __minus ? __minus + 1: __plus + 1;
              __beg = const_cast<char_type*>(__olds);
              __beglen = __sign - __olds;
              __end = const_cast<char_type*>(__sign + __plen);
              traits_type::copy(__news + __beglen, __pads, __plen);
            }
          else
            {

              __beg = __pads;
              __beglen = __plen;
              __end = const_cast<char_type*>(__olds);
            }
        }
      else
        {

          __beg = __pads;
          __beglen = __plen;
          __end = const_cast<char_type*>(__olds);
        }

      traits_type::copy(__news, __beg, __beglen);
      traits_type::copy(__news + __beglen, __end, __newlen - __beglen - __mod);
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          try
            {
              streamsize __w = __out.width();
              _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
              __pads[0] = __c;
              streamsize __len = 1;
              if (__w > __len)
                {
                  __pad_char(__out, __pads, &__c, __w, __len);
                  __len = __w;
                }
              __out.write(__pads, __len);
              __out.width(0);
            }
          catch(exception& __fail)
            {


              __out.setstate(ios_base::badbit);
              if ((__out.exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __out;
    }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          try
            {
              streamsize __w = __out.width();
              char* __pads = static_cast<char*>(__builtin_alloca(__w + 1));
              __pads[0] = __c;
              streamsize __len = 1;
              if (__w > __len)
                {
                  __pad_char(__out, __pads, &__c, __w, __len);
                  __len = __w;
                }
              __out.write(__pads, __len);
              __out.width(0);
            }
          catch(exception& __fail)
            {


              __out.setstate(ios_base::badbit);
              if ((__out.exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __out;
     }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          try
            {
              streamsize __w = __out.width();
              _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
              streamsize __len = static_cast<streamsize>(_Traits::length(__s));
              if (__w > __len)
                {
                  __pad_char(__out, __pads, __s, __w, __len);
                  __s = __pads;
                  __len = __w;
                }
              __out.write(__s, __len);
              __out.width(0);
            }
          catch(exception& __fail)
            {


              __out.setstate(ios_base::badbit);
              if ((__out.exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;


      typedef char_traits<char> __ctraits_type;

      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          size_t __clen = __ctraits_type::length(__s);
          _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__clen + 1)));
          for (size_t __i = 0; __i <= __clen; ++__i)
            __ws[__i] = __out.widen(__s[__i]);
          _CharT* __str = __ws;

          try
            {
              streamsize __len = static_cast<streamsize>(__clen);
              streamsize __w = __out.width();
              _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));

              if (__w > __len)
                {
                  __pad_char(__out, __pads, __ws, __w, __len);
                  __str = __pads;
                  __len = __w;
                }
              __out.write(__str, __len);
              __out.width(0);
            }
          catch(exception& __fail)
            {


              __out.setstate(ios_base::badbit);
              if ((__out.exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __out;
    }


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          try
            {
              streamsize __w = __out.width();
              char* __pads = static_cast<char*>(__builtin_alloca(__w));
              streamsize __len = static_cast<streamsize>(_Traits::length(__s));
              if (__w > __len)
                {
                  __pad_char(__out, __pads, __s, __w, __len);
                  __s = __pads;
                  __len = __w;
                }
              __out.write(__s, __len);
              __out.width(0);
            }
          catch(exception& __fail)
            {


              __out.setstate(ios_base::badbit);
              if ((__out.exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __out;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out,
               const basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
        {
          const _CharT* __s = __str.data();
          streamsize __w = __out.width();
          _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
          streamsize __len = static_cast<streamsize>(__str.size());



          if (__w > __len)
            {
              __pad_char(__out, __pads, __s, __w, __len);
              __s = __pads;
              __len = __w;
            }
          streamsize __res = __out.rdbuf()->sputn(__s, __len);
          __out.width(0);
          if (__res != __len)
            __out.setstate(ios_base::failbit);
        }
      return __out;
    }
}
# 279 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ostream.h" 2 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iostream.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_istream.h" 1 3
# 38 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_istream.h" 3

# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ios.h" 1 3
# 40 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_istream.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_limits.h" 1 3
# 41 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_istream.h" 2 3

namespace std
{

  template<typename _CharT, typename _Traits>
    class basic_istream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef istreambuf_iterator<_CharT, _Traits> __istreambuf_iter;
      typedef num_get<_CharT, __istreambuf_iter> __numget_type;
      typedef ctype<_CharT> __ctype_type;

    protected:

      streamsize _M_gcount;

    public:

      explicit
      basic_istream(__streambuf_type* __sb)
      {
        this->init(__sb);
        _M_gcount = streamsize(0);
      }

      virtual
      ~basic_istream()
      { _M_gcount = streamsize(0); }


      class sentry;
      friend class sentry;



      __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&));

      __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&));

      __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&));


      __istream_type&
      operator>>(bool& __n);

      __istream_type&
      operator>>(short& __n);

      __istream_type&
      operator>>(unsigned short& __n);

      __istream_type&
      operator>>(int& __n);

      __istream_type&
      operator>>(unsigned int& __n);

      __istream_type&
      operator>>(long& __n);

      __istream_type&
      operator>>(unsigned long& __n);
# 126 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_istream.h" 3
      __istream_type&
      operator>>(float& __f);

      __istream_type&
      operator>>(double& __f);

      __istream_type&
      operator>>(long double& __f);

      __istream_type&
      operator>>(void*& __p);

      __istream_type&
      operator>>(__streambuf_type* __sb);


      inline streamsize
      gcount(void) const
      { return _M_gcount; }

      int_type
      get(void);

      __istream_type&
      get(char_type& __c);

      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);

      inline __istream_type&
      get(char_type* __s, streamsize __n)
      { return get(__s, __n, this->widen('\n')); }

      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);

      inline __istream_type&
      get(__streambuf_type& __sb)
      { return get(__sb, this->widen('\n')); }

      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);

      inline __istream_type&
      getline(char_type* __s, streamsize __n)
      { return getline(__s, __n, this->widen('\n')); }

      __istream_type&
      ignore(streamsize __n = 1, int_type __delim = traits_type::eof());

      int_type
      peek(void);

      __istream_type&
      read(char_type* __s, streamsize __n);

      streamsize
      readsome(char_type* __s, streamsize __n);

      __istream_type&
      putback(char_type __c);

      __istream_type&
      unget(void);

      int
      sync(void);

      pos_type
      tellg(void);

      __istream_type&
      seekg(pos_type);

      __istream_type&
      seekg(off_type, ios_base::seekdir);

    private:


      __istream_type&
      operator=(const __istream_type&);

      basic_istream(const __istream_type&);

    };

  template<typename _CharT, typename _Traits>
    class basic_istream<_CharT, _Traits>::sentry
    {
    public:
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename _Traits::int_type __int_type;

      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);

      operator bool() { return _M_ok; }

    private:
      bool _M_ok;
    };


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);

  template<class _Traits>
    basic_istream<char,_Traits>&
    operator>>(basic_istream<char,_Traits>& __in, unsigned char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }

  template<class _Traits>
    basic_istream<char,_Traits>&
    operator>>(basic_istream<char,_Traits>& __in, signed char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }


  template<typename _CharT, typename _Traits>
    class basic_iostream
    : public basic_istream<_CharT, _Traits>,
      public basic_ostream<_CharT, _Traits>
    {
    public:

      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;

      explicit
      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
      : __istream_type(__sb), __ostream_type(__sb)
      { }

      virtual
      ~basic_iostream() { }
    };


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
}




# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/istream.tcc" 1 3
# 32 "/usr/local/gcc-3.0.1/include/g++-v3/bits/istream.tcc" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_locale.h" 1 3
# 33 "/usr/local/gcc-3.0.1/include/g++-v3/bits/istream.tcc" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_ostream.h" 1 3
# 34 "/usr/local/gcc-3.0.1/include/g++-v3/bits/istream.tcc" 2 3

namespace std
{
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>::sentry::
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
    {
      if (__in.good())
        {
          if (__in.tie())
            __in.tie()->flush();
          if (!__noskipws && (__in.flags() & ios_base::skipws))
            {
              const __int_type __eof = traits_type::eof();
              const __ctype_type* __ctype = __in._M_get_fctype_ios();
              __streambuf_type* __sb = __in.rdbuf();
              __int_type __c = __sb->sgetc();

              while (__c != __eof && __ctype->is(ctype_base::space, __c))
                __c = __sb->snextc();



              if (__c == __eof)
                __in.setstate(ios_base::eofbit);

            }
        }

      if (__in.good())
        _M_ok = true;
      else
        {
          _M_ok = false;
          __in.setstate(ios_base::failbit);
        }
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__istream_type& (*__pf)(__istream_type&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__ios_type& (*__pf)(__ios_type&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(ios_base& (*__pf)(ios_base&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(bool& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(short& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned short& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(int& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned int& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }
# 344 "/usr/local/gcc-3.0.1/include/g++-v3/bits/istream.tcc" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(float& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(void*& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
        {
          try
            {
              ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
              if (_M_check_facet(_M_fnumget))
                _M_fnumget->get(*this, 0, *this, __err, __n);
              this->setstate(__err);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__streambuf_type* __sbout)
    {
      streamsize __xtrct = 0;
      __streambuf_type* __sbin = this->rdbuf();
      sentry __cerb(*this, false);
      if (__sbout && __cerb)
        __xtrct = __copy_streambufs(*this, __sbin, __sbout);
      if (!__sbout || !__xtrct)
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    get(void)
    {
      const int_type __eof = traits_type::eof();
      int_type __c = __eof;
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              __c = this->rdbuf()->sbumpc();

              if (__c != __eof)
                _M_gcount = 1;
              else
                this->setstate(ios_base::eofbit | ios_base::failbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type& __c)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __eof = traits_type::eof();
              int_type __bufval = this->rdbuf()->sbumpc();

              if (__bufval != __eof)
                {
                  _M_gcount = 1;
                  __c = traits_type::to_char_type(__bufval);
                }
              else
                this->setstate(ios_base::eofbit | ios_base::failbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 1)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sbumpc();
              bool __testdelim = __c == __idelim;
              bool __testeof = __c == __eof;

              while (_M_gcount < __n - 1 && !__testeof && !__testdelim)
                {
                  *__s++ = traits_type::to_char_type(__c);
                  ++_M_gcount;
                  __c = __sb->sbumpc();
                  __testeof = __c == __eof;
                  __testdelim = __c == __idelim;
                }
              if (__testdelim || _M_gcount == __n - 1)
                __sb->sputbackc(__c);
              if (__testeof)
                this->setstate(ios_base::eofbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      *__s = char_type();
      if (!_M_gcount)
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(__streambuf_type& __sb, char_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          int_type __c;
          __streambuf_type* __this_sb = this->rdbuf();
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __c = __this_sb->sbumpc();
              bool __testdelim = __c == __idelim;
              bool __testeof = __c == __eof;
              bool __testput = true;

              while (!__testeof && !__testdelim
                    && (__testput = __sb.sputc(traits_type::to_char_type(__c))
                         != __eof))
                {
                  ++_M_gcount;
                  __c = __this_sb->sbumpc();
                  __testeof = __c == __eof;
                  __testdelim = __c == __idelim;
                }
              if (__testdelim || !__testput)
                __this_sb->sputbackc(traits_type::to_char_type(__c));
              if (__testeof)
                this->setstate(ios_base::eofbit);
            }
          catch(exception& __fail)
            {

              __this_sb->sputbackc(traits_type::to_char_type(__c));
            }
        }
      if (!_M_gcount)
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sbumpc();
              ++_M_gcount;
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              bool __testdelim = __c == __idelim;
              bool __testeof = __c == __eof;

              while (_M_gcount < __n && !__testeof && !__testdelim)
                {
                  *__s++ = traits_type::to_char_type(__c);
                  __c = __sb->sbumpc();
                  ++_M_gcount;
                  __testeof = __c == __eof;
                  __testdelim = __c == __idelim;
                }

              if (__testeof)
                {
                  --_M_gcount;
                  this->setstate(ios_base::eofbit);
                }
              else if (!__testdelim)
                {
                  --_M_gcount;
                  __sb->sputbackc(traits_type::to_char_type(__c));
                  this->setstate(ios_base::failbit);
                }
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      *__s = char_type();
      if (!_M_gcount)
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n, int_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sbumpc();
              bool __testdelim = __c == __idelim;
              bool __testeof = __c == __eof;

              __n = min(__n, numeric_limits<streamsize>::max());
              while (_M_gcount < __n - 1 && !__testeof && !__testdelim)
                {
                  ++_M_gcount;
                  __c = __sb->sbumpc();
                  __testeof = __c == __eof;
                  __testdelim = __c == __idelim;
                }
              if ((_M_gcount == __n - 1 && !__testeof) || __testdelim)
                ++_M_gcount;
              if (__testeof)
                this->setstate(ios_base::eofbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            { __c = this->rdbuf()->sgetc(); }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          if (__n > 0)
            {
              try
                {
                  const int_type __eof = traits_type::eof();
                  __streambuf_type* __sb = this->rdbuf();
                  int_type __c = __sb->sbumpc();
                  bool __testeof = __c == __eof;

                  while (_M_gcount < __n - 1 && !__testeof)
                    {
                      *__s++ = traits_type::to_char_type(__c);
                      ++_M_gcount;
                      __c = __sb->sbumpc();
                      __testeof = __c == __eof;
                    }
                  if (__testeof)
                    this->setstate(ios_base::eofbit | ios_base::failbit);
                  else
                    {

                      *__s++ = traits_type::to_char_type(__c);
                      ++_M_gcount;
                    }
                }
              catch(exception& __fail)
                {


                  this->setstate(ios_base::badbit);
                  if ((this->exceptions() & ios_base::badbit) != 0)
                    throw;
                }
            }
        }
      else
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      const int_type __eof = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          if (__n > 0)
            {
              try
                {
                  streamsize __num = this->rdbuf()->in_avail();
                  if (__num != static_cast<streamsize>(__eof))
                    {
                      __num = min(__num, __n);
                      _M_gcount = this->rdbuf()->sgetn(__s, __num);
                    }
                  else
                    this->setstate(ios_base::eofbit);
                }
              catch(exception& __fail)
                {


                  this->setstate(ios_base::badbit);
                  if ((this->exceptions() & ios_base::badbit) != 0)
                    throw;
                }
            }
        }
      else
        this->setstate(ios_base::failbit);
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              if (!__sb || __sb->sputbackc(__c) == __eof)
                this->setstate(ios_base::badbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      else
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              if (!__sb || __eof == __sb->sungetc())
                this->setstate(ios_base::badbit);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      else
        this->setstate(ios_base::failbit);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {
      int __ret = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              __streambuf_type* __sb = this->rdbuf();
              if (!__sb || __ret == __sb->pubsync())
                this->setstate(ios_base::badbit);
              else
                __ret = 0;
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {
      pos_type __ret = pos_type(-1);
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
             __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return __ret;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {


              pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);


              if (__err == pos_type(off_type(-1)))
                this->setstate(failbit);

            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {


              pos_type __err = this->rdbuf()->pubseekoff(__off, __dir,
                                                         ios_base::in);


              if (__err == pos_type(off_type(-1)))
                this->setstate(failbit);

            }
          catch(exception& __fail)
            {


              this->setstate(ios_base::badbit);
              if ((this->exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
        {
          try
            { __in.get(__c); }
          catch(exception& __fail)
            {


              __in.setstate(ios_base::badbit);
              if ((__in.exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      else
        __in.setstate(ios_base::failbit);
      return __in;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename _Traits::int_type int_type;
      typedef _CharT char_type;
      typedef ctype<_CharT> __ctype_type;
      streamsize __extracted = 0;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
        {
          try
            {

              streamsize __num = __in.width();
              if (__num == 0)
                __num = numeric_limits<streamsize>::max();

              __streambuf_type* __sb = __in.rdbuf();
              const __ctype_type* __ctype = __in._M_get_fctype_ios();
              int_type __c = __sb->sbumpc();
              const int_type __eof = _Traits::eof();
              bool __testsp = __ctype->is(ctype_base::space, __c);
              bool __testeof = __c == __eof;

              while (__extracted < __num - 1 && !__testeof && !__testsp)
                {
                  *__s++ = __c;
                  ++__extracted;
                  __c = __sb->sbumpc();
                  __testeof = __c == __eof;
                  __testsp = __ctype->is(ctype_base::space, __c);
                }

              if (!__testeof)
                __sb->sputbackc(__c);
              else
                __in.setstate(ios_base::eofbit);



              *__s = char_type();

              __in.width(0);
            }
          catch(exception& __fail)
            {


              __in.setstate(ios_base::badbit);
              if ((__in.exceptions() & ios_base::badbit) != 0)
                throw;
            }
        }
      if (!__extracted)
        __in.setstate(ios_base::failbit);
      return __in;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT,_Traits>&
    ws(basic_istream<_CharT,_Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __istream_type::char_type __char_type;

      __streambuf_type* __sb = __in.rdbuf();
      const __ctype_type* __ctype = __in._M_get_fctype_ios();
      const __int_type __eof = _Traits::eof();
      __int_type __c;
      bool __testeof;
      bool __testsp;

      do
        {
          __c = __sb->sbumpc();
          __testeof = __c == __eof;
          __testsp = __ctype->is(ctype_base::space, __c);
        }
      while (!__testeof && __testsp);

      if (!__testeof && !__testsp)
        __sb->sputbackc(__c);
      else
        __in.setstate(ios_base::eofbit);

      return __in;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
               basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __size_type __extracted = 0;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
        {
          __str.erase();
          streamsize __w = __in.width();
          __size_type __n;
          __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();

          __streambuf_type* __sb = __in.rdbuf();
          const __ctype_type* __ctype = __in._M_get_fctype_ios();
          __int_type __c = __sb->sbumpc();
          const __int_type __eof = _Traits::eof();
          bool __testsp = __ctype->is(ctype_base::space, __c);
          bool __testeof = __c == __eof;

          while (__extracted < __n && !__testeof && !__testsp)
            {
              __str += _Traits::to_char_type(__c);
              ++__extracted;
              __c = __sb->sbumpc();
              __testeof = __c == __eof;
              __testsp = __ctype->is(ctype_base::space, __c);
            }
          if (!__testeof)
            __sb->sputbackc(__c);
          else
            __in.setstate(ios_base::eofbit);
          __in.width(0);
        }


      if (!__extracted)
        __in.setstate (ios_base::failbit);

      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
            basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      bool __testdelim = false;
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
        {
          __str.erase();
          __size_type __n = __str.max_size();

          __int_type __idelim = _Traits::to_int_type(__delim);
          __streambuf_type* __sb = __in.rdbuf();
          __int_type __c = __sb->sbumpc();
          const __int_type __eof = _Traits::eof();
          __testdelim = __c == __idelim;
          bool __testeof = __c == __eof;

          while (__extracted <= __n && !__testeof && !__testdelim)
            {
              __str += _Traits::to_char_type(__c);
              ++__extracted;
              __c = __sb->sbumpc();
              __testeof = __c == __eof;
              __testdelim = __c == __idelim;
            }
          if (__testeof)
            __in.setstate(ios_base::eofbit);
        }
      if (!__extracted && !__testdelim)
        __in.setstate(ios_base::failbit);
      return __in;
    }

  template<class _CharT, class _Traits, class _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
            basic_string<_CharT,_Traits,_Alloc>& __str)
    { return getline(__in, __str, __in.widen('\n')); }
}
# 291 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_istream.h" 2 3
# 42 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iostream.h" 2 3

namespace std
{
  extern istream cin;
  extern ostream cout;
  extern ostream cerr;
  extern ostream clog;
# 57 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_iostream.h" 3
  static ios_base::Init __ioinit;
}
# 32 "/usr/local/gcc-3.0.1/include/g++-v3/iostream" 2 3
# 4 "test.cpp" 2
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/string" 1 3
# 5 "test.cpp" 2
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/algorithm" 1 3
# 6 "test.cpp" 2
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/functional" 1 3
# 31 "/usr/local/gcc-3.0.1/include/g++-v3/functional" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_functional.h" 1 3
# 48 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_functional.h" 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/sparcv9-sun-solaris2.8/bits/c++config.h" 1 3
# 49 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_functional.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_cstddef.h" 1 3
# 50 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_functional.h" 2 3
# 1 "/usr/local/gcc-3.0.1/include/g++-v3/bits/stl_function.h" 1 3
# 51 "/usr/local/gcc-3.0.1/include/g++-v3/bits/std_functional.h" 2 3
# 32 "/usr/local/gcc-3.0.1/include/g++-v3/functional" 2 3
# 7 "test.cpp" 2

using namespace std;

template<class A, class B>
struct pswap : public unary_function<pair<B, A>, pair<A, B> > {
        pair<B, A> operator()(const pair<A, B> &p) {
                return make_pair(p.second, p.first);
        }
};

ostream& operator<<(ostream& o, const pair<int, string>& p)
{
        o << p.first << " " << p.second;
        return o;
}

int main(void)
{
        string s;
        map<string, int> t;
        ostream_iterator< pair<int, string> > out(cout, "\n");
        pswap<string, int> pswap_func;

        while (cin >> s) t[s]++;
        vector< pair<int, string> > v;
        transform(t.begin(), t.end(), back_inserter(v), pswap_func);
        sort(v.begin(), v.end());
        copy(v.begin(), v.end(), out);
        return 0;
}


Here is the assembler output:
	.file	"test.ii"
	.section	".text"
	.align 4
	.type	asctime_r,#function
	.proc	0102
asctime_r:
.LLFB1:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI0:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	call	__posix_asctime_r, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE1:
.LLfe1:
	.size	asctime_r,.LLfe1-asctime_r
	.align 4
	.type	ctime_r,#function
	.proc	0102
ctime_r:
.LLFB2:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI1:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	call	__posix_ctime_r, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE2:
.LLfe2:
	.size	ctime_r,.LLfe2-ctime_r
	.section	".data"
	.align 8
	.type	__gthread_active_ptr,#object
	.size	__gthread_active_ptr,8
__gthread_active_ptr:
	.xword	pthread_create
	.local	_ZZ18__exchange_and_addPViiE6__lock
	.common	_ZZ18__exchange_and_addPViiE6__lock,1,1
	.section	".text"
	.align 4
	.type	_Z18__exchange_and_addPVii,#function
	.proc	04
_Z18__exchange_and_addPVii:
.LLFB3:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI2:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %i0
	st	%i0, [%fp+2183]
	sethi	%hh(_ZZ18__exchange_and_addPViiE6__lock), %i0
	or	%i0, %hm(_ZZ18__exchange_and_addPViiE6__lock), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZZ18__exchange_and_addPViiE6__lock), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZZ18__exchange_and_addPViiE6__lock), %i0
	1:	ldstub	[%i0], %o0
		cmp	%o0, 0
		bne	1b
		 nop
	mov	%o0, %i0
	st	%i0, [%fp+2019]
	ld	[%fp+2019], %i0
	st	%i0, [%fp+2023]
	ldx	[%fp+2175], %i0
	ld	[%i0], %i0
	st	%i0, [%fp+2027]
	ldx	[%fp+2175], %i0
	ld	[%i0], %i1
	ld	[%fp+2183], %i0
	add	%i1, %i0, %i1
	ldx	[%fp+2175], %i0
	st	%i1, [%i0]
	sethi	%hh(_ZZ18__exchange_and_addPViiE6__lock), %i0
	or	%i0, %hm(_ZZ18__exchange_and_addPViiE6__lock), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZZ18__exchange_and_addPViiE6__lock), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZZ18__exchange_and_addPViiE6__lock), %i0
	stb	%g0, [%i0]
	ldsw	[%fp+2027], %i0
	return	%i7+8
	nop
.LLFE3:
.LLfe3:
	.size	_Z18__exchange_and_addPVii,.LLfe3-_Z18__exchange_and_addPVii
	.local	_ZZ12__atomic_addPViiE6__lock
	.common	_ZZ12__atomic_addPViiE6__lock,1,1
	.align 4
	.type	_Z12__atomic_addPVii,#function
	.proc	020
_Z12__atomic_addPVii:
.LLFB4:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI3:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %i0
	st	%i0, [%fp+2183]
	sethi	%hh(_ZZ12__atomic_addPViiE6__lock), %i0
	or	%i0, %hm(_ZZ12__atomic_addPViiE6__lock), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZZ12__atomic_addPViiE6__lock), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZZ12__atomic_addPViiE6__lock), %i0
	1:	ldstub	[%i0], %o0
		cmp	%o0, 0
		bne	1b
		 nop
	mov	%o0, %i0
	st	%i0, [%fp+2023]
	ld	[%fp+2023], %i0
	st	%i0, [%fp+2027]
	ldx	[%fp+2175], %i0
	ld	[%i0], %i1
	ld	[%fp+2183], %i0
	add	%i1, %i0, %i1
	ldx	[%fp+2175], %i0
	st	%i1, [%i0]
	sethi	%hh(_ZZ12__atomic_addPViiE6__lock), %i0
	or	%i0, %hm(_ZZ12__atomic_addPViiE6__lock), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZZ12__atomic_addPViiE6__lock), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZZ12__atomic_addPViiE6__lock), %i0
	stb	%g0, [%i0]
	return	%i7+8
	nop
.LLFE4:
.LLfe4:
	.size	_Z12__atomic_addPVii,.LLfe4-_Z12__atomic_addPVii
	.local	_ZZ18__compare_and_swapPVlllE6__lock
	.common	_ZZ18__compare_and_swapPVlllE6__lock,1,1
	.align 4
	.type	_Z18__compare_and_swapPVlll,#function
	.proc	04
_Z18__compare_and_swapPVlll:
.LLFB5:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI4:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	sethi	%hh(_ZZ18__compare_and_swapPVlllE6__lock), %i0
	or	%i0, %hm(_ZZ18__compare_and_swapPVlllE6__lock), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZZ18__compare_and_swapPVlllE6__lock), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZZ18__compare_and_swapPVlllE6__lock), %i0
	1:	ldstub	[%i0], %o0
		cmp	%o0, 0
		bne	1b
		 nop
	mov	%o0, %i0
	stx	%i0, [%fp+2007]
	ldx	[%fp+2007], %i0
	stx	%i0, [%fp+2015]
	ldx	[%fp+2175], %i0
	ldx	[%i0], %i1
	ldx	[%fp+2183], %i0
	cmp	%i1, %i0
	be	%xcc, .LL10
	nop
	stx	%g0, [%fp+2023]
	ba,pt	%xcc, .LL11
	 nop
.LL10:
	ldx	[%fp+2191], %i0
	ldx	[%fp+2175], %i1
	stx	%i0, [%i1]
	mov	1, %i0
	stx	%i0, [%fp+2023]
.LL11:
	sethi	%hh(_ZZ18__compare_and_swapPVlllE6__lock), %i0
	or	%i0, %hm(_ZZ18__compare_and_swapPVlllE6__lock), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZZ18__compare_and_swapPVlllE6__lock), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZZ18__compare_and_swapPVlllE6__lock), %i0
	stb	%g0, [%i0]
	ldsw	[%fp+2027], %i0
	return	%i7+8
	nop
.LLFE5:
.LLfe5:
	.size	_Z18__compare_and_swapPVlll,.LLfe5-_Z18__compare_and_swapPVlll
	.section	".rodata"
	.align 8
.LLC0:
	.asciz	" "
	.section	".text"
	.align 4
	.global _ZlsRSoRKSt4pairIiSsE
	.type	_ZlsRSoRKSt4pairIiSsE,#function
	.proc	0110
_ZlsRSoRKSt4pairIiSsE:
.LLFB6:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI5:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2183], %o0
	ld	[%o0], %o0
	sra	%o0, 0, %o1
	ldx	[%fp+2175], %o0
	call	_ZNSolsEi, 0
	 nop
	sethi	%hh(.LLC0), %o1
	or	%o1, %hm(.LLC0), %o1
	sllx	%o1, 32, %o1
	sethi	%lm(.LLC0), %o2
	add	%o1, %o2, %o1
	or	%o1, %lo(.LLC0), %o1
	call	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc, 0
	 nop
	mov	%o0, %o2
	ldx	[%fp+2183], %o0
	add	%o0, 8, %o1
	mov	%o2, %o0
	call	_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E, 0
	 nop
	ldx	[%fp+2175], %i0
	return	%i7+8
	nop
.LLFE6:
.LLfe6:
	.size	_ZlsRSoRKSt4pairIiSsE,.LLfe6-_ZlsRSoRKSt4pairIiSsE
	.global _Unwind_Resume
	.section	".rodata"
	.align 8
.LLC1:
	.asciz	"\n"
	.section	".text"
	.align 4
	.global main
	.type	main,#function
	.proc	04
main:
.LLFB7:
	!#PROLOGUE# 0
	save	%sp, -480, %sp
.LLCFI6:
	!#PROLOGUE# 1
	add	%fp, 2015, %o0
.LLEHB0:
	call	_ZNSsC1Ev, 0
	 nop
.LLEHE0:
	add	%fp, 1983, %o0
.LLEHB1:
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev, 0
	 nop
.LLEHE1:
	add	%fp, 1967, %o0
	sethi	%hh(_ZSt4cout), %o1
	or	%o1, %hm(_ZSt4cout), %o1
	sllx	%o1, 32, %o1
	sethi	%lm(_ZSt4cout), %o2
	add	%o1, %o2, %o1
	or	%o1, %lo(_ZSt4cout), %o1
	sethi	%hh(.LLC1), %o2
	or	%o2, %hm(.LLC1), %o2
	sllx	%o2, 32, %o2
	sethi	%lm(.LLC1), %o3
	add	%o2, %o3, %o2
	or	%o2, %lo(.LLC1), %o2
.LLEHB2:
	call	_ZNSt16ostream_iteratorISt4pairIiSsEcSt11char_traitsIcEEC1ERSoPKc, 0
	 nop
.LL16:
	sethi	%hh(_ZSt3cin), %o0
	or	%o0, %hm(_ZSt3cin), %o0
	sllx	%o0, 32, %o0
	sethi	%lm(_ZSt3cin), %o1
	add	%o0, %o1, %o0
	or	%o0, %lo(_ZSt3cin), %o0
	add	%fp, 2015, %o1
	call	_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RSbIS4_S5_T1_E, 0
	 nop
	mov	%o0, %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	add	%o1, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEEcvPvEv, 0
	 nop
	brnz	%o0, .LL18
	nop
	ba,pt	%xcc, .LL17
	 nop
.LL18:
	add	%fp, 1983, %o0
	add	%fp, 2015, %o1
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_, 0
	 nop
.LLEHE2:
	ld	[%o0], %o1
	add	%o1, 1, %o1
	st	%o1, [%o0]
	ba,pt	%xcc, .LL16
	 nop
.LL17:
	add	%fp, 1903, %o0
	call	_ZNSaISt4pairIiSsEEC1Ev, 0
	 nop
	add	%fp, 1919, %o0
	add	%fp, 1903, %o1
.LLEHB3:
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EEC1ERKS2_, 0
	 nop
.LLEHE3:
	ba,pt	%xcc, .LL20
	 nop
.LL37:
	stx	%i0, [%fp+1839]
	ldx	[%fp+1839], %l0
	add	%fp, 1903, %o0
	call	_ZNSaISt4pairIiSsEED1Ev, 0
	 nop
	stx	%l0, [%fp+1839]
	ba,pt	%xcc, .LL27
	 nop
.LL20:
	add	%fp, 1903, %o0
	call	_ZNSaISt4pairIiSsEED1Ev, 0
	 nop
	add	%fp, 1903, %o0
	add	%fp, 1983, %o1
.LLEHB4:
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE5beginEv, 0
	 nop
	add	%fp, 1887, %o0
	add	%fp, 1983, %o1
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv, 0
	 nop
	add	%fp, 1919, %o0
	call	_ZSt13back_inserterISt6vectorISt4pairIiSsESaIS2_EEESt20back_insert_iteratorIT_ERS6_, 0
	 nop
	stx	%o0, [%fp+1879]
	add	%fp, 1903, %o0
	add	%fp, 1887, %o1
	ldx	[%fp+1879], %o2
	mov	0, %o3
	call	_ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_, 0
	 nop
	add	%fp, 1919, %o0
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv, 0
	 nop
	stx	%o0, [%fp+1871]
	add	%fp, 1919, %o0
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv, 0
	 nop
	stx	%o0, [%fp+1863]
	ldx	[%fp+1871], %o0
	ldx	[%fp+1863], %o1
	call	_ZSt4sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_, 0
	 nop
	ldx	[%fp+1967], %o0
	stx	%o0, [%fp+1903]
	ldx	[%fp+1975], %o0
	stx	%o0, [%fp+1911]
	add	%fp, 1919, %o0
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv, 0
	 nop
	stx	%o0, [%fp+1855]
	add	%fp, 1919, %o0
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv, 0
	 nop
	stx	%o0, [%fp+1847]
	add	%fp, 1887, %o0
	ldx	[%fp+1855], %o1
	ldx	[%fp+1847], %o2
	add	%fp, 1903, %o3
	call	_ZSt4copyISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_, 0
	 nop
.LLEHE4:
	add	%fp, 1919, %o0
.LLEHB5:
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev, 0
	 nop
.LLEHE5:
	add	%fp, 1983, %o0
.LLEHB6:
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEED1Ev, 0
	 nop
.LLEHE6:
	add	%fp, 2015, %o0
.LLEHB7:
	call	_ZNSsD1Ev, 0
	 nop
.LLEHE7:
	mov	0, %i0
	ba,pt	%xcc, .LL15
	 nop
.LL36:
	stx	%i0, [%fp+1839]
	ldx	[%fp+1839], %l0
	add	%fp, 1919, %o0
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev, 0
	 nop
	stx	%l0, [%fp+1839]
	ba,pt	%xcc, .LL27
	 nop
.LL38:
	stx	%i0, [%fp+1839]
.LL27:
	ldx	[%fp+1839], %l0
	add	%fp, 1983, %o0
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEED1Ev, 0
	 nop
	stx	%l0, [%fp+1839]
	ba,pt	%xcc, .LL31
	 nop
.LL39:
	stx	%i0, [%fp+1839]
.LL31:
	ldx	[%fp+1839], %l0
	add	%fp, 2015, %o0
	call	_ZNSsD1Ev, 0
	 nop
	stx	%l0, [%fp+1839]
	ldx	[%fp+1839], %o0
.LLEHB8:
	call	_Unwind_Resume, 0
	 nop
.LLEHE8:
.LL15:
	return	%i7+8
	nop
.LLFE7:
.LLfe7:
	.size	main,.LLfe7-main
.section	".gcc_except_table",#alloc,#write
.LLLSDA7:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x75
	.uaword	.LLEHB0-.LLFB7
	.uaword	.LLEHE0-.LLEHB0
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB1-.LLFB7
	.uaword	.LLEHE1-.LLEHB1
	.uaword	.LL39-.LLFB7
	.byte	0x0
	.uaword	.LLEHB2-.LLFB7
	.uaword	.LLEHE2-.LLEHB2
	.uaword	.LL38-.LLFB7
	.byte	0x0
	.uaword	.LLEHB3-.LLFB7
	.uaword	.LLEHE3-.LLEHB3
	.uaword	.LL37-.LLFB7
	.byte	0x0
	.uaword	.LLEHB4-.LLFB7
	.uaword	.LLEHE4-.LLEHB4
	.uaword	.LL36-.LLFB7
	.byte	0x0
	.uaword	.LLEHB5-.LLFB7
	.uaword	.LLEHE5-.LLEHB5
	.uaword	.LL38-.LLFB7
	.byte	0x0
	.uaword	.LLEHB6-.LLFB7
	.uaword	.LLEHE6-.LLEHB6
	.uaword	.LL39-.LLFB7
	.byte	0x0
	.uaword	.LLEHB7-.LLFB7
	.uaword	.LLEHE7-.LLEHB7
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB8-.LLFB7
	.uaword	.LLEHE8-.LLEHB8
	.uaword	0x0
	.byte	0x0
	.section	".text"
.section	".gnu.linkonce.t._ZNSolsEi",#alloc,#execinstr
	.align 4
	.weak	_ZNSolsEi
	.type	_ZNSolsEi,#function
	.proc	0110
_ZNSolsEi:
.LLFB8:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI7:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %o0
	st	%o0, [%fp+2023]
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	add	%o0, 8, %o0
	call	_ZNKSt8ios_base5flagsEv, 0
	 nop
	mov	74, %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	st	%o0, [%fp+2027]
	lduw	[%fp+2027], %o0
	mov	64, %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL42
	nop
	lduw	[%fp+2027], %o0
	mov	8, %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL42
	nop
	ba,pt	%xcc, .LL41
	 nop
.LL42:
	lduw	[%fp+2023], %o1
	ldx	[%fp+2175], %o0
	call	_ZNSolsEm, 0
	 nop
	mov	%o0, %i0
	ba,pt	%xcc, .LL40
	 nop
.LL41:
	ldsw	[%fp+2023], %o1
	ldx	[%fp+2175], %o0
	call	_ZNSolsEl, 0
	 nop
	mov	%o0, %i0
.LL40:
	return	%i7+8
	nop
.LLFE8:
.LLfe8:
	.size	_ZNSolsEi,.LLfe8-_ZNSolsEi
.section	".gnu.linkonce.t._ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc",#alloc,#execinstr
	.align 4
	.weak	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
	.type	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc,#function
	.proc	0110
_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc:
.LLFB9:
	!#PROLOGUE# 0
	save	%sp, -320, %sp
.LLCFI8:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
.LLEHB9:
	call	_ZNSo6sentryC1ERSo, 0
	 nop
.LLEHE9:
	add	%fp, 2015, %o0
.LLEHB10:
	call	_ZNSo6sentrycvbEv, 0
	 nop
.LLEHE10:
	cmp	%o0, 0
	be	%icc, .LL46
	nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	add	%o0, 8, %o0
.LLEHB11:
	call	_ZNKSt8ios_base5widthEv, 0
	 nop
	stx	%o0, [%fp+2007]
	ldx	[%fp+2007], %o0
	add	%o0, 15, %o0
	srlx	%o0, 4, %o0
	sllx	%o0, 4, %o0
	sub	%sp, %o0, %sp
	add	%sp, 2223, %o0
	add	%o0, 15, %o0
	srlx	%o0, 4, %o0
	sllx	%o0, 4, %o0
	stx	%o0, [%fp+1999]
	ldx	[%fp+2183], %o0
	call	_ZNSt11char_traitsIcE6lengthEPKc, 0
	 nop
	stx	%o0, [%fp+1991]
	ldx	[%fp+2007], %o1
	ldx	[%fp+1991], %o0
	cmp	%o1, %o0
	ble	%xcc, .LL47
	nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	ldx	[%fp+1999], %o1
	ldx	[%fp+2183], %o2
	ldx	[%fp+2007], %o3
	ldx	[%fp+1991], %o4
	call	_ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll, 0
	 nop
	ldx	[%fp+1999], %o0
	stx	%o0, [%fp+2183]
	ldx	[%fp+2007], %o0
	stx	%o0, [%fp+1991]
.LL47:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+1991], %o2
	call	_ZNSo5writeEPKcl, 0
	 nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	add	%o0, 8, %o0
	mov	0, %o1
	call	_ZNSt8ios_base5widthEl, 0
	 nop
.LLEHE11:
	ba,pt	%xcc, .LL46
	 nop
.LL62:
	stx	%i0, [%fp+1935]
	stx	%i1, [%fp+1919]
	ldx	[%fp+1919], %o0
	cmp	%o0, 1
	be	%xcc, .LL49
	nop
	ba,pt	%xcc, .LL55
	 nop
.LL49:
	ldx	[%fp+1935], %o0
	call	__cxa_begin_catch, 0
	 nop
	stx	%g0, [%fp+1991]
	stx	%o0, [%fp+1991]
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	mov	1, %o1
.LLEHB12:
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv, 0
	 nop
	mov	1, %o1
	call	_ZStanSt12_Ios_IostateS_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL52
	nop
	call	__cxa_rethrow, 0
	 nop
.LLEHE12:
.LL61:
	stx	%i0, [%fp+1935]
	ldx	[%fp+1935], %l0
	call	__cxa_end_catch, 0
	 nop
	stx	%l0, [%fp+1935]
	ba,pt	%xcc, .LL55
	 nop
.LL52:
	call	__cxa_end_catch, 0
	 nop
.LL46:
	add	%fp, 2015, %o0
.LLEHB13:
	call	_ZNSo6sentryD1Ev, 0
	 nop
.LLEHE13:
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL45
	 nop
.LL63:
	stx	%i0, [%fp+1935]
.LL55:
	ldx	[%fp+1935], %l0
	add	%fp, 2015, %o0
	call	_ZNSo6sentryD1Ev, 0
	 nop
	stx	%l0, [%fp+1935]
	ldx	[%fp+1935], %o0
.LLEHB14:
	call	_Unwind_Resume, 0
	 nop
.LLEHE14:
.LL45:
	return	%i7+8
	nop
.LLFE9:
.LLfe9:
	.size	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc,.LLfe9-_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
.section	".gcc_except_table",#alloc,#write
	.align 8
.LLLSDA9:
	.byte	0xff
	.byte	0x0
	.byte	0x5d
	.byte	0x3
	.byte	0x4e
	.uaword	.LLEHB9-.LLFB9
	.uaword	.LLEHE9-.LLEHB9
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB10-.LLFB9
	.uaword	.LLEHE10-.LLEHB10
	.uaword	.LL63-.LLFB9
	.byte	0x0
	.uaword	.LLEHB11-.LLFB9
	.uaword	.LLEHE11-.LLEHB11
	.uaword	.LL62-.LLFB9
	.byte	0x3
	.uaword	.LLEHB12-.LLFB9
	.uaword	.LLEHE12-.LLEHB12
	.uaword	.LL61-.LLFB9
	.byte	0x0
	.uaword	.LLEHB13-.LLFB9
	.uaword	.LLEHE13-.LLEHB13
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB14-.LLFB9
	.uaword	.LLEHE14-.LLEHB14
	.uaword	0x0
	.byte	0x0
	.byte	0x0
	.byte	0x0
	.byte	0x1
	.byte	0x7d
	.align 8
	.uaxword	_ZTISt9exception
.section	".gnu.linkonce.t._ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc",#alloc,#execinstr
.section	".gnu.linkonce.t._ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E",#alloc,#execinstr
	.align 4
	.weak	_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E
	.type	_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E,#function
	.proc	0110
_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E:
.LLFB10:
	!#PROLOGUE# 0
	save	%sp, -336, %sp
.LLCFI9:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
.LLEHB15:
	call	_ZNSo6sentryC1ERSo, 0
	 nop
.LLEHE15:
	add	%fp, 2015, %o0
.LLEHB16:
	call	_ZNSo6sentrycvbEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL65
	nop
	ldx	[%fp+2183], %o0
	call	_ZNKSs4dataEv, 0
	 nop
	stx	%o0, [%fp+2007]
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	add	%o0, 8, %o0
	call	_ZNKSt8ios_base5widthEv, 0
	 nop
	stx	%o0, [%fp+1999]
	ldx	[%fp+1999], %o0
	add	%o0, 15, %o0
	srlx	%o0, 4, %o0
	sllx	%o0, 4, %o0
	sub	%sp, %o0, %sp
	add	%sp, 2223, %o0
	add	%o0, 15, %o0
	srlx	%o0, 4, %o0
	sllx	%o0, 4, %o0
	stx	%o0, [%fp+1991]
	ldx	[%fp+2183], %o0
	call	_ZNKSs4sizeEv, 0
	 nop
	stx	%o0, [%fp+1983]
	ldx	[%fp+1999], %o1
	ldx	[%fp+1983], %o0
	cmp	%o1, %o0
	ble	%xcc, .LL66
	nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	ldx	[%fp+1991], %o1
	ldx	[%fp+2007], %o2
	ldx	[%fp+1999], %o3
	ldx	[%fp+1983], %o4
	call	_ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll, 0
	 nop
	ldx	[%fp+1991], %o0
	stx	%o0, [%fp+2007]
	ldx	[%fp+1999], %o0
	stx	%o0, [%fp+1983]
.LL66:
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	ldx	[%fp+2007], %o1
	ldx	[%fp+1983], %o2
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl, 0
	 nop
	stx	%o0, [%fp+1975]
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	add	%o0, 8, %o0
	mov	0, %o1
	call	_ZNSt8ios_base5widthEl, 0
	 nop
	ldx	[%fp+1975], %o1
	ldx	[%fp+1983], %o0
	cmp	%o1, %o0
	be	%xcc, .LL65
	nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	mov	4, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LLEHE16:
.LL65:
	add	%fp, 2015, %o0
.LLEHB17:
	call	_ZNSo6sentryD1Ev, 0
	 nop
.LLEHE17:
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL64
	 nop
.LL73:
	stx	%i0, [%fp+1919]
	ldx	[%fp+1919], %l0
	add	%fp, 2015, %o0
	call	_ZNSo6sentryD1Ev, 0
	 nop
	stx	%l0, [%fp+1919]
	ldx	[%fp+1919], %o0
.LLEHB18:
	call	_Unwind_Resume, 0
	 nop
.LLEHE18:
.LL64:
	return	%i7+8
	nop
.LLFE10:
.LLfe10:
	.size	_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E,.LLfe10-_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E
.section	".gcc_except_table",#alloc,#write
.LLLSDA10:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x34
	.uaword	.LLEHB15-.LLFB10
	.uaword	.LLEHE15-.LLEHB15
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB16-.LLFB10
	.uaword	.LLEHE16-.LLEHB16
	.uaword	.LL73-.LLFB10
	.byte	0x0
	.uaword	.LLEHB17-.LLFB10
	.uaword	.LLEHE17-.LLEHB17
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB18-.LLFB10
	.uaword	.LLEHE18-.LLEHB18
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKSbIS4_S5_T1_E",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSsC1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSsC1Ev
	.type	_ZNSsC1Ev,#function
	.proc	020
_ZNSsC1Ev:
.LLFB11:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI10:
	!#PROLOGUE# 1
	mov	%i0, %l0
.LLEHB19:
	call	_ZNSs12_S_empty_repEv, 0
	 nop
.LLEHE19:
	call	_ZNSs4_Rep10_M_refcopyEv, 0
	 nop
	mov	%o0, %l1
	add	%fp, 2015, %o0
	call	_ZNSaIcEC1Ev, 0
	 nop
	mov	%l0, %o0
	mov	%l1, %o1
	add	%fp, 2015, %o2
.LLEHB20:
	call	_ZNSs12_Alloc_hiderC1EPcRKSaIcE, 0
	 nop
.LLEHE20:
	ba,pt	%xcc, .LL76
	 nop
.LL83:
	stx	%i0, [%fp+2007]
	ldx	[%fp+2007], %l0
	add	%fp, 2015, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	stx	%l0, [%fp+2007]
	ldx	[%fp+2007], %o0
.LLEHB21:
	call	_Unwind_Resume, 0
	 nop
.LLEHE21:
.LL76:
	add	%fp, 2015, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	return	%i7+8
	nop
.LLFE11:
.LLfe11:
	.size	_ZNSsC1Ev,.LLfe11-_ZNSsC1Ev
.section	".gcc_except_table",#alloc,#write
.LLLSDA11:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x27
	.uaword	.LLEHB19-.LLFB11
	.uaword	.LLEHE19-.LLEHB19
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB20-.LLFB11
	.uaword	.LLEHE20-.LLEHB20
	.uaword	.LL83-.LLFB11
	.byte	0x0
	.uaword	.LLEHB21-.LLFB11
	.uaword	.LLEHE21-.LLEHB21
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSsC1Ev",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSsD1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSsD1Ev
	.type	_ZNSsD1Ev,#function
	.proc	020
_ZNSsD1Ev:
.LLFB12:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI11:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	ldx	[%fp+2175], %o0
.LLEHB22:
	call	_ZNKSs6_M_repEv, 0
	 nop
	mov	%o0, %l0
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
	call	_ZNKSs13get_allocatorEv, 0
	 nop
.LLEHE22:
	mov	%l0, %o0
	add	%fp, 2015, %o1
.LLEHB23:
	call	_ZNSs4_Rep10_M_disposeERKSaIcE, 0
	 nop
.LLEHE23:
	ba,pt	%xcc, .LL86
	 nop
.LL90:
	stx	%i0, [%fp+2007]
	ldx	[%fp+2007], %l0
	add	%fp, 2015, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	stx	%l0, [%fp+2007]
	ldx	[%fp+2007], %o0
.LLEHB24:
	call	_Unwind_Resume, 0
	 nop
.LLEHE24:
.LL86:
	add	%fp, 2015, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	ldx	[%fp+2175], %o0
	call	_ZNSs12_Alloc_hiderD1Ev, 0
	 nop
	return	%i7+8
	nop
.LLFE12:
.LLfe12:
	.size	_ZNSsD1Ev,.LLfe12-_ZNSsD1Ev
.section	".gcc_except_table",#alloc,#write
.LLLSDA12:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x27
	.uaword	.LLEHB22-.LLFB12
	.uaword	.LLEHE22-.LLEHB22
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB23-.LLFB12
	.uaword	.LLEHE23-.LLEHB23
	.uaword	.LL90-.LLFB12
	.byte	0x0
	.uaword	.LLEHB24-.LLFB12
	.uaword	.LLEHE24-.LLEHB24
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSsD1Ev",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev
	.type	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev,#function
	.proc	020
_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev:
.LLFB13:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI12:
	!#PROLOGUE# 1
	mov	%i0, %l0
	add	%fp, 2015, %o0
	call	_ZNSaISt4pairIKSsiEEC1Ev, 0
	 nop
	stb	%g0, [%fp+2014]
	mov	%l0, %o0
	add	%fp, 2014, %o1
	add	%fp, 2015, %o2
.LLEHB25:
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_, 0
	 nop
.LLEHE25:
	ba,pt	%xcc, .LL93
	 nop
.LL100:
	stx	%i0, [%fp+1999]
	ldx	[%fp+1999], %l0
	add	%fp, 2015, %o0
	call	_ZNSaISt4pairIKSsiEED1Ev, 0
	 nop
	stx	%l0, [%fp+1999]
	ldx	[%fp+1999], %o0
.LLEHB26:
	call	_Unwind_Resume, 0
	 nop
.LLEHE26:
.LL93:
	add	%fp, 2015, %o0
	call	_ZNSaISt4pairIKSsiEED1Ev, 0
	 nop
	return	%i7+8
	nop
.LLFE13:
.LLfe13:
	.size	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev,.LLfe13-_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev
.section	".gcc_except_table",#alloc,#write
.LLLSDA13:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x1a
	.uaword	.LLEHB25-.LLFB13
	.uaword	.LLEHE25-.LLEHB25
	.uaword	.LL100-.LLFB13
	.byte	0x0
	.uaword	.LLEHB26-.LLFB13
	.uaword	.LLEHE26-.LLEHB26
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEC1Ev",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt16ostream_iteratorISt4pairIiSsEcSt11char_traitsIcEEC1ERSoPKc",#alloc,#execinstr
	.align 4
	.weak	_ZNSt16ostream_iteratorISt4pairIiSsEcSt11char_traitsIcEEC1ERSoPKc
	.type	_ZNSt16ostream_iteratorISt4pairIiSsEcSt11char_traitsIcEEC1ERSoPKc,#function
	.proc	020
_ZNSt16ostream_iteratorISt4pairIiSsEcSt11char_traitsIcEEC1ERSoPKc:
.LLFB14:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI13:
	!#PROLOGUE# 1
	stx	%i1, [%i0]
	stx	%i2, [%i0+8]
	return	%i7+8
	nop
.LLFE14:
.LLfe14:
	.size	_ZNSt16ostream_iteratorISt4pairIiSsEcSt11char_traitsIcEEC1ERSoPKc,.LLfe14-_ZNSt16ostream_iteratorISt4pairIiSsEcSt11char_traitsIcEEC1ERSoPKc
.section	".gnu.linkonce.t._ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RSbIS4_S5_T1_E",#alloc,#execinstr
	.align 4
	.weak	_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RSbIS4_S5_T1_E
	.type	_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RSbIS4_S5_T1_E,#function
	.proc	0110
_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RSbIS4_S5_T1_E:
.LLFB15:
	!#PROLOGUE# 0
	save	%sp, -272, %sp
.LLCFI14:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%g0, [%fp+2023]
	add	%fp, 2022, %o0
	ldx	[%fp+2175], %o1
	mov	0, %o2
	call	_ZNSi6sentryC1ERSib, 0
	 nop
	add	%fp, 2022, %o0
	call	_ZNSi6sentrycvbEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL103
	nop
	ldx	[%fp+2183], %o0
	mov	0, %o1
	mov	-1, %o2
	call	_ZNSs5eraseEmm, 0
	 nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	add	%o0, 8, %o0
	call	_ZNKSt8ios_base5widthEv, 0
	 nop
	stx	%o0, [%fp+2007]
	ldx	[%fp+2007], %o0
	brgz	%o0, .LL104
	nop
	ldx	[%fp+2183], %o0
	call	_ZNKSs8max_sizeEv, 0
	 nop
	stx	%o0, [%fp+1959]
	ba,pt	%xcc, .LL105
	 nop
.LL104:
	ldx	[%fp+2007], %o0
	stx	%o0, [%fp+1959]
.LL105:
	ldx	[%fp+1959], %o0
	stx	%o0, [%fp+1999]
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	stx	%o0, [%fp+1991]
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv, 0
	 nop
	stx	%o0, [%fp+1983]
	ldx	[%fp+1991], %o0
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv, 0
	 nop
	st	%o0, [%fp+1979]
	call	_ZNSt11char_traitsIcE3eofEv, 0
	 nop
	st	%o0, [%fp+1975]
	ldub	[%fp+1982], %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o2
	ldx	[%fp+1983], %o0
	mov	8, %o1
	call	_ZNKSt5ctypeIcE2isEjc, 0
	 nop
	stb	%o0, [%fp+1974]
	ld	[%fp+1979], %o1
	ld	[%fp+1975], %o0
	xor	%o1, %o0, %o0
	subcc	%g0, %o0, %g0
	subx	%g0, -1, %o0
	stb	%o0, [%fp+1973]
.LL106:
	ldx	[%fp+2023], %o1
	ldx	[%fp+1999], %o0
	cmp	%o1, %o0
	bgeu	%xcc, .LL107
	nop
	ldub	[%fp+1973], %o0
	cmp	%o0, 0
	bne	%icc, .LL107
	nop
	ldub	[%fp+1974], %o0
	cmp	%o0, 0
	bne	%icc, .LL107
	nop
	add	%fp, 1979, %o0
	call	_ZNSt11char_traitsIcE12to_char_typeERKi, 0
	 nop
	mov	%o0, %o1
	ldx	[%fp+2183], %o0
	call	_ZNSspLEc, 0
	 nop
	ldx	[%fp+2023], %o0
	add	%o0, 1, %o0
	stx	%o0, [%fp+2023]
	ldx	[%fp+1991], %o0
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv, 0
	 nop
	st	%o0, [%fp+1979]
	ld	[%fp+1979], %o1
	ld	[%fp+1975], %o0
	xor	%o1, %o0, %o0
	subcc	%g0, %o0, %g0
	subx	%g0, -1, %o0
	stb	%o0, [%fp+1973]
	ldub	[%fp+1982], %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o2
	ldx	[%fp+1983], %o0
	mov	8, %o1
	call	_ZNKSt5ctypeIcE2isEjc, 0
	 nop
	stb	%o0, [%fp+1974]
	ba,pt	%xcc, .LL106
	 nop
.LL107:
	ldub	[%fp+1973], %o0
	cmp	%o0, 0
	bne	%icc, .LL110
	nop
	ldub	[%fp+1982], %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o1
	ldx	[%fp+1991], %o0
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE9sputbackcEc, 0
	 nop
	ba,pt	%xcc, .LL111
	 nop
.LL110:
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	mov	2, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LL111:
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	add	%o0, 8, %o0
	mov	0, %o1
	call	_ZNSt8ios_base5widthEl, 0
	 nop
.LL103:
	ldx	[%fp+2023], %o0
	brnz	%o0, .LL112
	nop
	ldx	[%fp+2175], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	add	%o0, %o1, %o0
	mov	4, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LL112:
	ldx	[%fp+2175], %i0
	return	%i7+8
	nop
.LLFE15:
.LLfe15:
	.size	_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RSbIS4_S5_T1_E,.LLfe15-_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RSbIS4_S5_T1_E
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEEcvPvEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEEcvPvEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEEcvPvEv,#function
	.proc	0120
_ZNKSt9basic_iosIcSt11char_traitsIcEEcvPvEv:
.LLFB16:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI15:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	ldx	[%fp+2175], %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL115
	nop
	mov	0, %o0
	stx	%o0, [%fp+2023]
	ba,pt	%xcc, .LL116
	 nop
.LL115:
	ldx	[%fp+2175], %o0
	stx	%o0, [%fp+2023]
.LL116:
	ldx	[%fp+2023], %i0
	return	%i7+8
	nop
.LLFE16:
.LLfe16:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEEcvPvEv,.LLfe16-_ZNKSt9basic_iosIcSt11char_traitsIcEEcvPvEv
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_
	.type	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_,#function
	.proc	0104
_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_:
.LLFB17:
	!#PROLOGUE# 0
	save	%sp, -320, %sp
.LLCFI16:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
	ldx	[%fp+2183], %o2
.LLEHB27:
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE11lower_boundERS3_, 0
	 nop
	stb	%g0, [%fp+1930]
	add	%fp, 1999, %o0
	ldx	[%fp+2175], %o1
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv, 0
	 nop
	add	%fp, 2015, %o0
	add	%fp, 1999, %o1
	call	_ZSteqISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL121
	nop
	ldx	[%fp+2175], %o0
	call	_ZNKSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE8key_compEv, 0
	 nop
	mov	%o0, %o1
	srax	%o1, 56, %o1
	ldub	[%fp+1998], %o0
	and	%o0, 0, %o0
	mov	%o0, %o2
	mov	%o1, %o0
	or	%o2, %o0, %o0
	stb	%o0, [%fp+1998]
	add	%fp, 2015, %o0
	call	_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv, 0
	 nop
	mov	%o0, %o2
	add	%fp, 1998, %o0
	ldx	[%fp+2183], %o1
	call	_ZNKSt4lessISsEclERKSsS2_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL121
	nop
	ba,pt	%xcc, .LL120
	 nop
.LL121:
	mov	1, %o0
	stb	%o0, [%fp+1930]
.LL120:
	ldub	[%fp+1930], %o0
	cmp	%o0, 0
	be	%icc, .LL119
	nop
	add	%fp, 1951, %o0
	add	%fp, 2015, %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_, 0
	 nop
	st	%g0, [%fp+1931]
	add	%fp, 1935, %o0
	ldx	[%fp+2183], %o1
	add	%fp, 1931, %o2
	call	_ZNSt4pairIKSsiEC1ERS0_RKi, 0
	 nop
.LLEHE27:
	add	%fp, 1967, %o0
	ldx	[%fp+2175], %o1
	add	%fp, 1951, %o2
	add	%fp, 1935, %o3
.LLEHB28:
	call	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE6insertESt17_Rb_tree_iteratorIS4_RS4_PS4_ERKS4_, 0
	 nop
.LLEHE28:
	ldx	[%fp+1967], %o0
	stx	%o0, [%fp+2015]
	ba,pt	%xcc, .LL123
	 nop
.LL127:
	stx	%i0, [%fp+1919]
	ldx	[%fp+1919], %l0
	add	%fp, 1935, %o0
	call	_ZNSt4pairIKSsiED1Ev, 0
	 nop
	stx	%l0, [%fp+1919]
	ldx	[%fp+1919], %o0
.LLEHB29:
	call	_Unwind_Resume, 0
	 nop
.LL123:
	add	%fp, 1935, %o0
	call	_ZNSt4pairIKSsiED1Ev, 0
	 nop
.LL119:
	add	%fp, 2015, %o0
	call	_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv, 0
	 nop
.LLEHE29:
	add	%o0, 8, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE17:
.LLfe17:
	.size	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_,.LLfe17-_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_
.section	".gcc_except_table",#alloc,#write
.LLLSDA17:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x27
	.uaword	.LLEHB27-.LLFB17
	.uaword	.LLEHE27-.LLEHB27
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB28-.LLFB17
	.uaword	.LLEHE28-.LLEHB28
	.uaword	.LL127-.LLFB17
	.byte	0x0
	.uaword	.LLEHB29-.LLFB17
	.uaword	.LLEHE29-.LLEHB29
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEEixERS3_",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSaISt4pairIiSsEEC1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSaISt4pairIiSsEEC1Ev
	.type	_ZNSaISt4pairIiSsEEC1Ev,#function
	.proc	020
_ZNSaISt4pairIiSsEEC1Ev:
.LLFB18:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI17:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE18:
.LLfe18:
	.size	_ZNSaISt4pairIiSsEEC1Ev,.LLfe18-_ZNSaISt4pairIiSsEEC1Ev
.section	".gnu.linkonce.t._ZNSaISt4pairIiSsEED1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSaISt4pairIiSsEED1Ev
	.type	_ZNSaISt4pairIiSsEED1Ev,#function
	.proc	020
_ZNSaISt4pairIiSsEED1Ev:
.LLFB19:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI18:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE19:
.LLfe19:
	.size	_ZNSaISt4pairIiSsEED1Ev,.LLfe19-_ZNSaISt4pairIiSsEED1Ev
.section	".gnu.linkonce.t._ZNSt6vectorISt4pairIiSsESaIS1_EEC1ERKS2_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt6vectorISt4pairIiSsESaIS1_EEC1ERKS2_
	.type	_ZNSt6vectorISt4pairIiSsESaIS1_EEC1ERKS2_,#function
	.proc	020
_ZNSt6vectorISt4pairIiSsESaIS1_EEC1ERKS2_:
.LLFB20:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI19:
	!#PROLOGUE# 1
	mov	%i0, %o0
	mov	%i1, %o1
	call	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EEC2ERKS2_, 0
	 nop
	return	%i7+8
	nop
.LLFE20:
.LLfe20:
	.size	_ZNSt6vectorISt4pairIiSsESaIS1_EEC1ERKS2_,.LLfe20-_ZNSt6vectorISt4pairIiSsESaIS1_EEC1ERKS2_
.section	".gnu.linkonce.t._ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev
	.type	_ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev,#function
	.proc	020
_ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev:
.LLFB21:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI20:
	!#PROLOGUE# 1
	mov	%i0, %l0
	ldx	[%l0], %o0
	ldx	[%l0+8], %o1
	call	_ZSt7destroyIPSt4pairIiSsEEvT_S3_, 0
	 nop
	mov	%l0, %o0
	call	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EED2Ev, 0
	 nop
	return	%i7+8
	nop
.LLFE21:
.LLfe21:
	.size	_ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev,.LLfe21-_ZNSt6vectorISt4pairIiSsESaIS1_EED1Ev
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE5beginEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE5beginEv
	.type	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE5beginEv,#function
	.proc	010
_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE5beginEv:
.LLFB22:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI21:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	mov	%l0, %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE5beginEv, 0
	 nop
	return	%i7+8
	nop
.LLFE22:
.LLfe22:
	.size	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE5beginEv,.LLfe22-_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE5beginEv
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv
	.type	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv,#function
	.proc	010
_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv:
.LLFB23:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI22:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	mov	%l0, %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE3endEv, 0
	 nop
	return	%i7+8
	nop
.LLFE23:
.LLfe23:
	.size	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv,.LLfe23-_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE3endEv
.section	".gnu.linkonce.t._ZSt13back_inserterISt6vectorISt4pairIiSsESaIS2_EEESt20back_insert_iteratorIT_ERS6_",#alloc,#execinstr
	.align 4
	.weak	_ZSt13back_inserterISt6vectorISt4pairIiSsESaIS2_EEESt20back_insert_iteratorIT_ERS6_
	.type	_ZSt13back_inserterISt6vectorISt4pairIiSsESaIS2_EEESt20back_insert_iteratorIT_ERS6_,#function
	.proc	010
_ZSt13back_inserterISt6vectorISt4pairIiSsESaIS2_EEESt20back_insert_iteratorIT_ERS6_:
.LLFB24:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI23:
	!#PROLOGUE# 1
	mov	%i0, %o1
	add	%fp, 2023, %o0
	call	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEC1ERS4_, 0
	 nop
	ldx	[%fp+2023], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE24:
.LLfe24:
	.size	_ZSt13back_inserterISt6vectorISt4pairIiSsESaIS2_EEESt20back_insert_iteratorIT_ERS6_,.LLfe24-_ZSt13back_inserterISt6vectorISt4pairIiSsESaIS2_EEESt20back_insert_iteratorIT_ERS6_
.section	".gnu.linkonce.t._ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_
	.type	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_,#function
	.proc	020
_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_:
.LLFB25:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI24:
	!#PROLOGUE# 1
	ldx	[%i1], %i1
	stx	%i1, [%i0]
	return	%i7+8
	nop
.LLFE25:
.LLfe25:
	.size	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_,.LLfe25-_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_
.section	".gnu.linkonce.t._ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_",#alloc,#execinstr
	.align 4
	.weak	_ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_
	.type	_ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_,#function
	.proc	010
_ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_:
.LLFB26:
	!#PROLOGUE# 0
	save	%sp, -272, %sp
.LLCFI25:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	mov	%i3, %o1
	srax	%o1, 56, %o1
	ldub	[%fp+2199], %o0
	and	%o0, 0, %o0
	mov	%o0, %o2
	mov	%o1, %o0
	or	%o2, %o0, %o0
	stb	%o0, [%fp+2199]
.LL150:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
.LLEHB30:
	call	_ZStneISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL153
	nop
	ba,pt	%xcc, .LL151
	 nop
.LL153:
	add	%fp, 2191, %o0
	call	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEdeEv, 0
	 nop
	stx	%o0, [%fp+1991]
	ldx	[%fp+2175], %o0
	call	_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv, 0
	 nop
	mov	%o0, %o1
	add	%fp, 1999, %o0
	call	_ZNSt4pairISsiEC1IKSsiEERKS_IT_T0_E, 0
	 nop
.LLEHE30:
	add	%fp, 2015, %o0
	add	%fp, 2199, %o1
	add	%fp, 1999, %o2
.LLEHB31:
	call	_ZN5pswapISsiEclERKSt4pairISsiE, 0
	 nop
.LLEHE31:
	ldx	[%fp+1991], %o0
	add	%fp, 2015, %o1
.LLEHB32:
	call	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEaSERKS2_, 0
	 nop
.LLEHE32:
	ba,pt	%xcc, .LL155
	 nop
.LL163:
	stx	%i0, [%fp+1983]
	ldx	[%fp+1983], %l0
	add	%fp, 2015, %o0
	call	_ZNSt4pairIiSsED1Ev, 0
	 nop
	stx	%l0, [%fp+1983]
	ba,pt	%xcc, .LL158
	 nop
.LL155:
	add	%fp, 2015, %o0
.LLEHB33:
	call	_ZNSt4pairIiSsED1Ev, 0
	 nop
.LLEHE33:
	add	%fp, 1999, %o0
.LLEHB34:
	call	_ZNSt4pairISsiED1Ev, 0
	 nop
	ldx	[%fp+2175], %o0
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EppEv, 0
	 nop
	add	%fp, 2191, %o0
	call	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEppEv, 0
	 nop
.LLEHE34:
	ba,pt	%xcc, .LL150
	 nop
.LL164:
	stx	%i0, [%fp+1983]
.LL158:
	ldx	[%fp+1983], %l0
	add	%fp, 1999, %o0
	call	_ZNSt4pairISsiED1Ev, 0
	 nop
	stx	%l0, [%fp+1983]
	ldx	[%fp+1983], %o0
.LLEHB35:
	call	_Unwind_Resume, 0
	 nop
.LLEHE35:
.LL151:
	ldx	[%fp+2191], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE26:
.LLfe26:
	.size	_ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_,.LLfe26-_ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_
.section	".gcc_except_table",#alloc,#write
.LLLSDA26:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x4e
	.uaword	.LLEHB30-.LLFB26
	.uaword	.LLEHE30-.LLEHB30
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB31-.LLFB26
	.uaword	.LLEHE31-.LLEHB31
	.uaword	.LL164-.LLFB26
	.byte	0x0
	.uaword	.LLEHB32-.LLFB26
	.uaword	.LLEHE32-.LLEHB32
	.uaword	.LL163-.LLFB26
	.byte	0x0
	.uaword	.LLEHB33-.LLFB26
	.uaword	.LLEHE33-.LLEHB33
	.uaword	.LL164-.LLFB26
	.byte	0x0
	.uaword	.LLEHB34-.LLFB26
	.uaword	.LLEHE34-.LLEHB34
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB35-.LLFB26
	.uaword	.LLEHE35-.LLEHB35
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZSt9transformISt17_Rb_tree_iteratorISt4pairIKSsiERS3_PS3_ESt20back_insert_iteratorISt6vectorIS1_IiSsESaIS9_EEE5pswapISsiEET0_T_SG_SF_T1_",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv
	.type	_ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv,#function
	.proc	010
_ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv:
.LLFB27:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI26:
	!#PROLOGUE# 1
	mov	%i0, %o1
	add	%fp, 2023, %o0
	call	_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_, 0
	 nop
	ldx	[%fp+2023], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE27:
.LLfe27:
	.size	_ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv,.LLfe27-_ZNSt6vectorISt4pairIiSsESaIS1_EE5beginEv
.section	".gnu.linkonce.t._ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv
	.type	_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv,#function
	.proc	010
_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv:
.LLFB28:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI27:
	!#PROLOGUE# 1
	mov	%i0, %o0
	add	%o0, 8, %o1
	add	%fp, 2023, %o0
	call	_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_, 0
	 nop
	ldx	[%fp+2023], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE28:
.LLfe28:
	.size	_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv,.LLfe28-_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv
.section	".gnu.linkonce.t._ZSt4sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_",#alloc,#execinstr
	.align 4
	.weak	_ZSt4sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_
	.type	_ZSt4sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_,#function
	.proc	020
_ZSt4sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_:
.LLFB29:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI28:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	add	%fp, 2175, %o0
	add	%fp, 2183, %o1
	call	_ZStneIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL171
	nop
	add	%fp, 2175, %o0
	call	_ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_, 0
	 nop
	mov	%o0, %l0
	add	%fp, 2183, %o0
	add	%fp, 2175, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_, 0
	 nop
	call	_ZSt4__lgIlET_S0_, 0
	 nop
	add	%o0, %o0, %o3
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	mov	%l0, %o2
	call	_ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_, 0
	 nop
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	call	_ZSt22__final_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_, 0
	 nop
.LL171:
	return	%i7+8
	nop
.LLFE29:
.LLfe29:
	.size	_ZSt4sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_,.LLfe29-_ZSt4sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_
.section	".gnu.linkonce.t._ZSt4copyISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_",#alloc,#execinstr
	.align 4
	.weak	_ZSt4copyISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_
	.type	_ZSt4copyISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_,#function
	.proc	010
_ZSt4copyISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_:
.LLFB30:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI29:
	!#PROLOGUE# 1
	mov	%i0, %l0
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	mov	%i3, %o1
	ldx	[%o1], %o0
	stx	%o0, [%fp+2015]
	ldx	[%o1+8], %o0
	stx	%o0, [%fp+2023]
	stb	%g0, [%fp+2014]
	mov	%l0, %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2191], %o2
	add	%fp, 2015, %o3
	mov	0, %o4
	call	_ZSt10__copy_ni1ISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_5_BoolILb1EE, 0
	 nop
	return	%i7+8
	nop
.LLFE30:
.LLfe30:
	.size	_ZSt4copyISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_,.LLfe30-_ZSt4copyISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_
.section	".gnu.linkonce.t._ZNSolsEm",#alloc,#execinstr
	.align 4
	.weak	_ZNSolsEm
	.type	_ZNSolsEm,#function
	.proc	0110
_ZNSolsEm:
.LLFB31:
	!#PROLOGUE# 0
	save	%sp, -288, %sp
.LLCFI30:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
.LLEHB36:
	call	_ZNSo6sentryC1ERSo, 0
	 nop
.LLEHE36:
	add	%fp, 2015, %o0
.LLEHB37:
	call	_ZNSo6sentrycvbEv, 0
	 nop
.LLEHE37:
	cmp	%o0, 0
	be	%icc, .LL175
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o3
	add	%o3, %o0, %o2
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o3
	add	%o3, %o0, %o1
	mov	%o2, %o0
	ldx	[%o1+248], %o1
.LLEHB38:
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL175
	nop
	add	%fp, 1983, %o0
	ldx	[%fp+2175], %o1
	call	_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo, 0
	 nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv, 0
	 nop
	mov	%o0, %o4
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o1
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o0
	add	%o0, 8, %o3
	add	%fp, 1999, %o0
	ldx	[%o1+248], %o1
	add	%fp, 1983, %o2
	ldx	[%fp+2183], %o5
	call	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm, 0
	 nop
	add	%fp, 1999, %o0
	call	_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL175
	nop
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	mov	1, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LLEHE38:
	ba,pt	%xcc, .LL175
	 nop
.LL192:
	stx	%i0, [%fp+1967]
	stx	%i1, [%fp+1951]
	ldx	[%fp+1951], %o2
	cmp	%o2, 1
	be	%xcc, .LL179
	nop
	ba,pt	%xcc, .LL185
	 nop
.LL179:
	ldx	[%fp+1967], %o0
	call	__cxa_begin_catch, 0
	 nop
	stx	%g0, [%fp+1975]
	stx	%o0, [%fp+1975]
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	mov	1, %o1
.LLEHB39:
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
	ldx	[%fp+2175], %o2
	ldx	[%o2], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o3
	add	%o3, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv, 0
	 nop
	mov	1, %o1
	call	_ZStanSt12_Ios_IostateS_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL182
	nop
	call	__cxa_rethrow, 0
	 nop
.LLEHE39:
.LL191:
	stx	%i0, [%fp+1967]
	ldx	[%fp+1967], %l0
	call	__cxa_end_catch, 0
	 nop
	stx	%l0, [%fp+1967]
	ba,pt	%xcc, .LL185
	 nop
.LL182:
	call	__cxa_end_catch, 0
	 nop
.LL175:
	add	%fp, 2015, %o0
.LLEHB40:
	call	_ZNSo6sentryD1Ev, 0
	 nop
.LLEHE40:
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL174
	 nop
.LL193:
	stx	%i0, [%fp+1967]
.LL185:
	ldx	[%fp+1967], %l0
	add	%fp, 2015, %o0
	call	_ZNSo6sentryD1Ev, 0
	 nop
	stx	%l0, [%fp+1967]
	ldx	[%fp+1967], %o0
.LLEHB41:
	call	_Unwind_Resume, 0
	 nop
.LLEHE41:
.LL174:
	return	%i7+8
	nop
.LLFE31:
.LLfe31:
	.size	_ZNSolsEm,.LLfe31-_ZNSolsEm
.section	".gcc_except_table",#alloc,#write
	.align 8
.LLLSDA31:
	.byte	0xff
	.byte	0x0
	.byte	0x5d
	.byte	0x3
	.byte	0x4e
	.uaword	.LLEHB36-.LLFB31
	.uaword	.LLEHE36-.LLEHB36
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB37-.LLFB31
	.uaword	.LLEHE37-.LLEHB37
	.uaword	.LL193-.LLFB31
	.byte	0x0
	.uaword	.LLEHB38-.LLFB31
	.uaword	.LLEHE38-.LLEHB38
	.uaword	.LL192-.LLFB31
	.byte	0x3
	.uaword	.LLEHB39-.LLFB31
	.uaword	.LLEHE39-.LLEHB39
	.uaword	.LL191-.LLFB31
	.byte	0x0
	.uaword	.LLEHB40-.LLFB31
	.uaword	.LLEHE40-.LLEHB40
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB41-.LLFB31
	.uaword	.LLEHE41-.LLEHB41
	.uaword	0x0
	.byte	0x0
	.byte	0x0
	.byte	0x0
	.byte	0x1
	.byte	0x7d
	.align 8
	.uaxword	_ZTISt9exception
.section	".gnu.linkonce.t._ZNSolsEm",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSolsEl",#alloc,#execinstr
	.align 4
	.weak	_ZNSolsEl
	.type	_ZNSolsEl,#function
	.proc	0110
_ZNSolsEl:
.LLFB32:
	!#PROLOGUE# 0
	save	%sp, -304, %sp
.LLCFI31:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
.LLEHB42:
	call	_ZNSo6sentryC1ERSo, 0
	 nop
.LLEHE42:
	add	%fp, 2015, %o0
.LLEHB43:
	call	_ZNSo6sentrycvbEv, 0
	 nop
.LLEHE43:
	cmp	%o0, 0
	be	%icc, .LL195
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o0
.LLEHB44:
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv, 0
	 nop
	stb	%o0, [%fp+2014]
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	add	%o0, 8, %o0
	call	_ZNKSt8ios_base5flagsEv, 0
	 nop
	mov	74, %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	st	%o0, [%fp+2007]
	ldx	[%fp+2175], %o2
	ldx	[%o2], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o3
	add	%o3, %o0, %o2
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o3
	add	%o3, %o0, %o1
	mov	%o2, %o0
	ldx	[%o1+248], %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL195
	nop
	stb	%g0, [%fp+2006]
	lduw	[%fp+2007], %o0
	mov	64, %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL198
	nop
	lduw	[%fp+2007], %o0
	mov	8, %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL198
	nop
	ba,pt	%xcc, .LL197
	 nop
.LL198:
	ldx	[%fp+2183], %o0
	stx	%o0, [%fp+1991]
	add	%fp, 1951, %o0
	ldx	[%fp+2175], %o1
	call	_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo, 0
	 nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o1
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o0
	add	%o0, 8, %o3
	ldub	[%fp+2014], %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o4
	add	%fp, 1967, %o0
	ldx	[%o1+248], %o1
	add	%fp, 1951, %o2
	ldx	[%fp+1991], %o5
	call	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm, 0
	 nop
	add	%fp, 1967, %o0
	call	_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv, 0
	 nop
	stb	%o0, [%fp+2006]
	ba,pt	%xcc, .LL199
	 nop
.LL197:
	add	%fp, 1967, %o0
	ldx	[%fp+2175], %o1
	call	_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo, 0
	 nop
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o1
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o2
	add	%o2, %o0, %o0
	add	%o0, 8, %o3
	ldub	[%fp+2014], %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o4
	add	%fp, 1951, %o0
	ldx	[%o1+248], %o1
	add	%fp, 1967, %o2
	ldx	[%fp+2183], %o5
	call	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecl, 0
	 nop
	add	%fp, 1951, %o0
	call	_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv, 0
	 nop
	stb	%o0, [%fp+2006]
.LL199:
	ldub	[%fp+2006], %o0
	cmp	%o0, 0
	be	%icc, .LL195
	nop
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	mov	1, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LLEHE44:
	ba,pt	%xcc, .LL195
	 nop
.LL215:
	stx	%i0, [%fp+1943]
	stx	%i1, [%fp+1927]
	ldx	[%fp+1927], %o2
	cmp	%o2, 1
	be	%xcc, .LL202
	nop
	ba,pt	%xcc, .LL208
	 nop
.LL202:
	ldx	[%fp+1943], %o0
	call	__cxa_begin_catch, 0
	 nop
	stx	%g0, [%fp+1991]
	stx	%o0, [%fp+1991]
	ldx	[%fp+2175], %o3
	ldx	[%o3], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	mov	1, %o1
.LLEHB45:
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
	ldx	[%fp+2175], %o2
	ldx	[%o2], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o3
	add	%o3, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv, 0
	 nop
	mov	1, %o1
	call	_ZStanSt12_Ios_IostateS_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL205
	nop
	call	__cxa_rethrow, 0
	 nop
.LLEHE45:
.LL214:
	stx	%i0, [%fp+1943]
	ldx	[%fp+1943], %l0
	call	__cxa_end_catch, 0
	 nop
	stx	%l0, [%fp+1943]
	ba,pt	%xcc, .LL208
	 nop
.LL205:
	call	__cxa_end_catch, 0
	 nop
.LL195:
	add	%fp, 2015, %o0
.LLEHB46:
	call	_ZNSo6sentryD1Ev, 0
	 nop
.LLEHE46:
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL194
	 nop
.LL216:
	stx	%i0, [%fp+1943]
.LL208:
	ldx	[%fp+1943], %l0
	add	%fp, 2015, %o0
	call	_ZNSo6sentryD1Ev, 0
	 nop
	stx	%l0, [%fp+1943]
	ldx	[%fp+1943], %o0
.LLEHB47:
	call	_Unwind_Resume, 0
	 nop
.LLEHE47:
.LL194:
	return	%i7+8
	nop
.LLFE32:
.LLfe32:
	.size	_ZNSolsEl,.LLfe32-_ZNSolsEl
.section	".gcc_except_table",#alloc,#write
	.align 8
.LLLSDA32:
	.byte	0xff
	.byte	0x0
	.byte	0x5d
	.byte	0x3
	.byte	0x4e
	.uaword	.LLEHB42-.LLFB32
	.uaword	.LLEHE42-.LLEHB42
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB43-.LLFB32
	.uaword	.LLEHE43-.LLEHB43
	.uaword	.LL216-.LLFB32
	.byte	0x0
	.uaword	.LLEHB44-.LLFB32
	.uaword	.LLEHE44-.LLEHB44
	.uaword	.LL215-.LLFB32
	.byte	0x3
	.uaword	.LLEHB45-.LLFB32
	.uaword	.LLEHE45-.LLEHB45
	.uaword	.LL214-.LLFB32
	.byte	0x0
	.uaword	.LLEHB46-.LLFB32
	.uaword	.LLEHE46-.LLEHB46
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB47-.LLFB32
	.uaword	.LLEHE47-.LLEHB47
	.uaword	0x0
	.byte	0x0
	.byte	0x0
	.byte	0x0
	.byte	0x1
	.byte	0x7d
	.align 8
	.uaxword	_ZTISt9exception
.section	".gnu.linkonce.t._ZNSolsEl",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSo6sentryC1ERSo",#alloc,#execinstr
	.align 4
	.weak	_ZNSo6sentryC1ERSo
	.type	_ZNSo6sentryC1ERSo,#function
	.proc	020
_ZNSo6sentryC1ERSo:
.LLFB33:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI32:
	!#PROLOGUE# 1
	mov	%i0, %l0
	stx	%i1, [%fp+2183]
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv, 0
	 nop
	stb	%o0, [%l0]
	ldx	[%fp+2183], %o0
	stx	%o0, [%l0+8]
	ldub	[%l0], %o0
	and	%o0, 0xff, %o0
	cmp	%o0, 0
	be	%icc, .LL217
	nop
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv, 0
	 nop
	brz	%o0, .LL217
	nop
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv, 0
	 nop
	call	_ZNSo5flushEv, 0
	 nop
.LL217:
	return	%i7+8
	nop
.LLFE33:
.LLfe33:
	.size	_ZNSo6sentryC1ERSo,.LLfe33-_ZNSo6sentryC1ERSo
.section	".gnu.linkonce.t._ZNSo6sentryD1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSo6sentryD1Ev
	.type	_ZNSo6sentryD1Ev,#function
	.proc	020
_ZNSo6sentryD1Ev:
.LLFB34:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI33:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	ldx	[%fp+2175], %o1
	ldx	[%o1+8], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%fp+2175], %o2
	ldx	[%o2+8], %o1
	ldx	[%o0], %o0
	add	%o1, %o0, %o0
	add	%o0, 8, %o0
	call	_ZNKSt8ios_base5flagsEv, 0
	 nop
	sethi	%hi(8192), %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL219
	nop
	call	_ZSt18uncaught_exceptionv, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL219
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1+8], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%fp+2175], %o2
	ldx	[%o2+8], %o1
	ldx	[%o0], %o0
	add	%o1, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	brz	%o0, .LL219
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1+8], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%fp+2175], %o2
	ldx	[%o2+8], %o1
	ldx	[%o0], %o0
	add	%o1, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv, 0
	 nop
	cmp	%o0, -1
	bne	%icc, .LL219
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1+8], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%fp+2175], %o2
	ldx	[%o2+8], %o1
	ldx	[%o0], %o0
	add	%o1, %o0, %o0
	mov	1, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LL219:
	return	%i7+8
	nop
.LLFE34:
.LLfe34:
	.size	_ZNSo6sentryD1Ev,.LLfe34-_ZNSo6sentryD1Ev
.section	".gnu.linkonce.t._ZNSo6sentrycvbEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSo6sentrycvbEv
	.type	_ZNSo6sentrycvbEv,#function
	.proc	00
_ZNSo6sentrycvbEv:
.LLFB35:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI34:
	!#PROLOGUE# 1
	ldub	[%i0], %i0
	and	%i0, 0xff, %i0
	return	%i7+8
	nop
.LLFE35:
.LLfe35:
	.size	_ZNSo6sentrycvbEv,.LLfe35-_ZNSo6sentrycvbEv
.section	".gnu.linkonce.t._ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll",#alloc,#execinstr
	.align 4
	.weak	_ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll
	.type	_ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll,#function
	.proc	020
_ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll:
.LLFB36:
	!#PROLOGUE# 0
	save	%sp, -368, %sp
.LLCFI35:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	stx	%i3, [%fp+2199]
	stx	%i4, [%fp+2207]
	ld	[%fp+2203], %o1
	ld	[%fp+2211], %o0
	sub	%o1, %o0, %o0
	st	%o0, [%fp+2027]
	ldsw	[%fp+2027], %o0
	add	%o0, 15, %o0
	srlx	%o0, 4, %o0
	sllx	%o0, 4, %o0
	sub	%sp, %o0, %sp
	add	%sp, 2223, %o0
	add	%o0, 15, %o0
	srlx	%o0, 4, %o0
	sllx	%o0, 4, %o0
	stx	%o0, [%fp+2015]
	ldx	[%fp+2175], %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv, 0
	 nop
	mov	%o0, %o2
	ldsw	[%fp+2027], %o1
	ldx	[%fp+2015], %o0
	call	_ZNSt11char_traitsIcE6assignEPcmc, 0
	 nop
	stx	%g0, [%fp+1991]
	ldx	[%fp+2175], %o0
	add	%o0, 8, %o0
	call	_ZNKSt8ios_base5flagsEv, 0
	 nop
	mov	176, %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	st	%o0, [%fp+1979]
	ld	[%fp+1979], %o0
	cmp	%o0, 32
	bne	%icc, .LL226
	nop
	ldx	[%fp+2191], %o0
	stx	%o0, [%fp+2007]
	ldx	[%fp+2207], %o0
	stx	%o0, [%fp+1983]
	ldx	[%fp+2015], %o0
	stx	%o0, [%fp+1999]
	ba,pt	%xcc, .LL227
	 nop
.LL226:
	ld	[%fp+1979], %o0
	cmp	%o0, 16
	bne	%icc, .LL228
	nop
	ldx	[%fp+2175], %o0
	add	%o0, 8, %o0
	call	_ZNSt13_Format_cacheIcE6_S_getERSt8ios_base, 0
	 nop
	stx	%o0, [%fp+1967]
	stb	%g0, [%fp+1958]
	ldx	[%fp+2191], %o0
	ldx	[%fp+2207], %o1
	add	%fp, 1958, %o2
	call	_ZNSt11char_traitsIcE4findEPKcmRS1_, 0
	 nop
	stx	%o0, [%fp+1959]
	mov	1, %o0
	stb	%o0, [%fp+1942]
	ldx	[%fp+2191], %o0
	ldx	[%fp+2207], %o1
	add	%fp, 1942, %o2
	call	_ZNSt11char_traitsIcE4findEPKcmRS1_, 0
	 nop
	stx	%o0, [%fp+1943]
	stb	%g0, [%fp+1941]
	ldx	[%fp+1959], %o0
	brnz	%o0, .LL230
	nop
	ldx	[%fp+1943], %o0
	brnz	%o0, .LL230
	nop
	ba,pt	%xcc, .LL229
	 nop
.LL230:
	mov	1, %o0
	stb	%o0, [%fp+1941]
.LL229:
	stb	%g0, [%fp+1878]
	ldx	[%fp+2191], %o0
	ldub	[%o0], %o0
	sll	%o0, 24, %o0
	sra	%o0, 24, %o0
	cmp	%o0, 48
	bne	%icc, .LL231
	nop
	ldx	[%fp+2191], %o0
	add	%o0, 1, %o0
	ldub	[%o0], %o0
	sll	%o0, 24, %o0
	sra	%o0, 24, %o0
	cmp	%o0, 120
	be	%icc, .LL232
	nop
	ldx	[%fp+2191], %o0
	add	%o0, 1, %o0
	ldub	[%o0], %o0
	sll	%o0, 24, %o0
	sra	%o0, 24, %o0
	cmp	%o0, 88
	be	%icc, .LL232
	nop
	ba,pt	%xcc, .LL231
	 nop
.LL232:
	mov	1, %o0
	stb	%o0, [%fp+1878]
.LL231:
	ldub	[%fp+1878], %o0
	stb	%o0, [%fp+1940]
	ldub	[%fp+1940], %o0
	cmp	%o0, 0
	be	%icc, .LL233
	nop
	ldx	[%fp+2191], %o0
	ldub	[%o0], %o1
	ldx	[%fp+2183], %o0
	stb	%o1, [%o0]
	ldx	[%fp+2183], %o0
	add	%o0, 1, %o1
	ldx	[%fp+2191], %o0
	add	%o0, 1, %o0
	ldub	[%o0], %o0
	stb	%o0, [%o1]
	ldx	[%fp+1991], %o0
	add	%o0, 2, %o0
	stx	%o0, [%fp+1991]
	ldx	[%fp+2191], %o1
	ldx	[%fp+1991], %o0
	add	%o1, %o0, %o0
	stx	%o0, [%fp+2007]
	ldx	[%fp+2207], %o1
	ldx	[%fp+1991], %o0
	sub	%o1, %o0, %o0
	stx	%o0, [%fp+1983]
	ldx	[%fp+2015], %o0
	stx	%o0, [%fp+1999]
	ba,pt	%xcc, .LL227
	 nop
.LL233:
	ldub	[%fp+1941], %o0
	cmp	%o0, 0
	be	%icc, .LL235
	nop
	ldsw	[%fp+2027], %o1
	ldx	[%fp+1991], %o0
	add	%o0, %o1, %o0
	stx	%o0, [%fp+1991]
	ldx	[%fp+1959], %o0
	brz	%o0, .LL236
	nop
	ldx	[%fp+1959], %o0
	add	%o0, 1, %o0
	stx	%o0, [%fp+1863]
	ba,pt	%xcc, .LL237
	 nop
.LL236:
	ldx	[%fp+1943], %o0
	add	%o0, 1, %o0
	stx	%o0, [%fp+1863]
.LL237:
	ldx	[%fp+1863], %o0
	stx	%o0, [%fp+1927]
	ldx	[%fp+2191], %o0
	stx	%o0, [%fp+2007]
	ldx	[%fp+1927], %o1
	ldx	[%fp+2191], %o0
	sub	%o1, %o0, %o0
	stx	%o0, [%fp+1983]
	ldsw	[%fp+2027], %o1
	ldx	[%fp+1927], %o0
	add	%o0, %o1, %o0
	stx	%o0, [%fp+1999]
	ldx	[%fp+2183], %o1
	ldx	[%fp+1983], %o0
	add	%o1, %o0, %o0
	ldsw	[%fp+2027], %o2
	ldx	[%fp+2015], %o1
	call	_ZNSt11char_traitsIcE4copyEPcPKcm, 0
	 nop
	ba,pt	%xcc, .LL227
	 nop
.LL235:
	ldx	[%fp+2015], %o0
	stx	%o0, [%fp+2007]
	ldsw	[%fp+2027], %o0
	stx	%o0, [%fp+1983]
	ldx	[%fp+2191], %o0
	stx	%o0, [%fp+1999]
	ba,pt	%xcc, .LL227
	 nop
.LL228:
	ldx	[%fp+2015], %o0
	stx	%o0, [%fp+2007]
	ldsw	[%fp+2027], %o0
	stx	%o0, [%fp+1983]
	ldx	[%fp+2191], %o0
	stx	%o0, [%fp+1999]
.LL227:
	ldx	[%fp+2183], %o0
	ldx	[%fp+2007], %o1
	ldx	[%fp+1983], %o2
	call	_ZNSt11char_traitsIcE4copyEPcPKcm, 0
	 nop
	ldx	[%fp+2183], %o1
	ldx	[%fp+1983], %o0
	add	%o1, %o0, %o3
	ldx	[%fp+2199], %o1
	ldx	[%fp+1983], %o0
	sub	%o1, %o0, %o1
	ldx	[%fp+1991], %o0
	sub	%o1, %o0, %o2
	mov	%o3, %o0
	ldx	[%fp+1999], %o1
	call	_ZNSt11char_traitsIcE4copyEPcPKcm, 0
	 nop
	return	%i7+8
	nop
.LLFE36:
.LLfe36:
	.size	_ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll,.LLfe36-_ZSt10__pad_charIcSt11char_traitsIcEEvRSt9basic_iosIT_T0_EPS3_PKS3_ll
.section	".gnu.linkonce.t._ZNSo5writeEPKcl",#alloc,#execinstr
	.align 4
	.weak	_ZNSo5writeEPKcl
	.type	_ZNSo5writeEPKcl,#function
	.proc	0110
_ZNSo5writeEPKcl:
.LLFB37:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI36:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
.LLEHB48:
	call	_ZNSo6sentryC1ERSo, 0
	 nop
.LLEHE48:
	add	%fp, 2015, %o0
	call	_ZNSo6sentrycvbEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL242
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
.LLEHB49:
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	ldx	[%fp+2183], %o1
	ldx	[%fp+2191], %o2
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl, 0
	 nop
	stx	%o0, [%fp+2007]
	ldx	[%fp+2007], %o1
	ldx	[%fp+2191], %o0
	cmp	%o1, %o0
	be	%xcc, .LL242
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	mov	1, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LLEHE49:
.LL242:
	add	%fp, 2015, %o0
.LLEHB50:
	call	_ZNSo6sentryD1Ev, 0
	 nop
.LLEHE50:
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL241
	 nop
.LL249:
	stx	%i0, [%fp+1999]
	ldx	[%fp+1999], %l0
	add	%fp, 2015, %o0
	call	_ZNSo6sentryD1Ev, 0
	 nop
	stx	%l0, [%fp+1999]
	ldx	[%fp+1999], %o0
.LLEHB51:
	call	_Unwind_Resume, 0
	 nop
.LLEHE51:
.LL241:
	return	%i7+8
	nop
.LLFE37:
.LLfe37:
	.size	_ZNSo5writeEPKcl,.LLfe37-_ZNSo5writeEPKcl
.section	".gcc_except_table",#alloc,#write
.LLLSDA37:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x34
	.uaword	.LLEHB48-.LLFB37
	.uaword	.LLEHE48-.LLEHB48
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB49-.LLFB37
	.uaword	.LLEHE49-.LLEHB49
	.uaword	.LL249-.LLFB37
	.byte	0x0
	.uaword	.LLEHB50-.LLFB37
	.uaword	.LLEHE50-.LLEHB50
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB51-.LLFB37
	.uaword	.LLEHE51-.LLEHB51
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSo5writeEPKcl",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate",#alloc,#execinstr
	.align 4
	.weak	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate
	.type	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate,#function
	.proc	020
_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate:
.LLFB38:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI37:
	!#PROLOGUE# 1
	mov	%i0, %l1
	mov	%i1, %o0
	mov	%o0, %l0
	mov	%l1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv, 0
	 nop
	srl	%l0, 0, %o1
	call	_ZStorSt12_Ios_IostateS_, 0
	 nop
	mov	%o0, %o1
	mov	%l1, %o0
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate, 0
	 nop
	return	%i7+8
	nop
.LLFE38:
.LLfe38:
	.size	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate,.LLfe38-_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv,#function
	.proc	012
_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv:
.LLFB39:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI38:
	!#PROLOGUE# 1
	ld	[%i0+220], %i0
	srl	%i0, 0, %i0
	return	%i7+8
	nop
.LLFE39:
.LLfe39:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv,.LLfe39-_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv
.section	".gnu.linkonce.t._ZNKSs4dataEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs4dataEv
	.type	_ZNKSs4dataEv,#function
	.proc	0102
_ZNKSs4dataEv:
.LLFB40:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI39:
	!#PROLOGUE# 1
	mov	%i0, %o0
	call	_ZNKSs7_M_dataEv, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE40:
.LLfe40:
	.size	_ZNKSs4dataEv,.LLfe40-_ZNKSs4dataEv
.section	".gnu.linkonce.t._ZNKSs4sizeEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs4sizeEv
	.type	_ZNKSs4sizeEv,#function
	.proc	017
_ZNKSs4sizeEv:
.LLFB41:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI40:
	!#PROLOGUE# 1
	mov	%i0, %o0
	call	_ZNKSs6_M_repEv, 0
	 nop
	ldx	[%o0], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE41:
.LLfe41:
	.size	_ZNKSs4sizeEv,.LLfe41-_ZNKSs4sizeEv
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv,#function
	.proc	0110
_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv:
.LLFB42:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI41:
	!#PROLOGUE# 1
	ldx	[%i0+224], %i0
	return	%i7+8
	nop
.LLFE42:
.LLfe42:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv,.LLfe42-_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv
.section	".gnu.linkonce.t._ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl",#alloc,#execinstr
	.align 4
	.weak	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl
	.type	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl,#function
	.proc	05
_ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl:
.LLFB43:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI42:
	!#PROLOGUE# 1
	mov	%i0, %o1
	mov	%i1, %o2
	mov	%i2, %o4
	ldx	[%o1], %o0
	add	%o0, 96, %o0
	ldx	[%o0], %o3
	mov	%o1, %o0
	mov	%o2, %o1
	mov	%o4, %o2
	call	%o3, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE43:
.LLfe43:
	.size	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl,.LLfe43-_ZNSt15basic_streambufIcSt11char_traitsIcEE5sputnEPKcl
.section	".gnu.linkonce.t._ZNSs12_S_empty_repEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSs12_S_empty_repEv
	.type	_ZNSs12_S_empty_repEv,#function
	.proc	0110
_ZNSs12_S_empty_repEv:
.LLFB44:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI43:
	!#PROLOGUE# 1
	sethi	%hh(_ZNSs20_S_empty_rep_storageE), %i0
	or	%i0, %hm(_ZNSs20_S_empty_rep_storageE), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZNSs20_S_empty_rep_storageE), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZNSs20_S_empty_rep_storageE), %i0
	return	%i7+8
	nop
.LLFE44:
.LLfe44:
	.size	_ZNSs12_S_empty_repEv,.LLfe44-_ZNSs12_S_empty_repEv
.section	".gnu.linkonce.t._ZNSs4_Rep10_M_refcopyEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSs4_Rep10_M_refcopyEv
	.type	_ZNSs4_Rep10_M_refcopyEv,#function
	.proc	0102
_ZNSs4_Rep10_M_refcopyEv:
.LLFB45:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI44:
	!#PROLOGUE# 1
	mov	%i0, %l0
	add	%l0, 16, %o0
	mov	1, %o1
	call	_Z12__atomic_addPVii, 0
	 nop
	mov	%l0, %o0
	call	_ZNSs4_Rep10_M_refdataEv, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE45:
.LLfe45:
	.size	_ZNSs4_Rep10_M_refcopyEv,.LLfe45-_ZNSs4_Rep10_M_refcopyEv
.section	".gnu.linkonce.t._ZNSaIcEC1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSaIcEC1Ev
	.type	_ZNSaIcEC1Ev,#function
	.proc	020
_ZNSaIcEC1Ev:
.LLFB46:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI45:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE46:
.LLfe46:
	.size	_ZNSaIcEC1Ev,.LLfe46-_ZNSaIcEC1Ev
.section	".gnu.linkonce.t._ZNSaIcED1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSaIcED1Ev
	.type	_ZNSaIcED1Ev,#function
	.proc	020
_ZNSaIcED1Ev:
.LLFB47:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI46:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE47:
.LLfe47:
	.size	_ZNSaIcED1Ev,.LLfe47-_ZNSaIcED1Ev
.section	".gnu.linkonce.t._ZNSs12_Alloc_hiderC1EPcRKSaIcE",#alloc,#execinstr
	.align 4
	.weak	_ZNSs12_Alloc_hiderC1EPcRKSaIcE
	.type	_ZNSs12_Alloc_hiderC1EPcRKSaIcE,#function
	.proc	020
_ZNSs12_Alloc_hiderC1EPcRKSaIcE:
.LLFB48:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI47:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %l1
	mov	%i2, %o1
	mov	%l0, %o0
	call	_ZNSaIcEC2ERKS_, 0
	 nop
	stx	%l1, [%l0]
	return	%i7+8
	nop
.LLFE48:
.LLfe48:
	.size	_ZNSs12_Alloc_hiderC1EPcRKSaIcE,.LLfe48-_ZNSs12_Alloc_hiderC1EPcRKSaIcE
.section	".gnu.linkonce.t._ZNKSs6_M_repEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs6_M_repEv
	.type	_ZNKSs6_M_repEv,#function
	.proc	0110
_ZNKSs6_M_repEv:
.LLFB49:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI48:
	!#PROLOGUE# 1
	mov	%i0, %o0
	call	_ZNKSs7_M_dataEv, 0
	 nop
	add	%o0, -24, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE49:
.LLfe49:
	.size	_ZNKSs6_M_repEv,.LLfe49-_ZNKSs6_M_repEv
.section	".gnu.linkonce.t._ZNKSs13get_allocatorEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs13get_allocatorEv
	.type	_ZNKSs13get_allocatorEv,#function
	.proc	010
_ZNKSs13get_allocatorEv:
.LLFB50:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI49:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	mov	%l0, %o0
	call	_ZNSaIcEC1ERKS_, 0
	 nop
	return	%i7+8
	nop
.LLFE50:
.LLfe50:
	.size	_ZNKSs13get_allocatorEv,.LLfe50-_ZNKSs13get_allocatorEv
.section	".gnu.linkonce.t._ZNSs4_Rep10_M_disposeERKSaIcE",#alloc,#execinstr
	.align 4
	.weak	_ZNSs4_Rep10_M_disposeERKSaIcE
	.type	_ZNSs4_Rep10_M_disposeERKSaIcE,#function
	.proc	020
_ZNSs4_Rep10_M_disposeERKSaIcE:
.LLFB51:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI50:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2175], %o1
	add	%o1, 16, %o0
	mov	-1, %o1
	call	_Z18__exchange_and_addPVii, 0
	 nop
	cmp	%o0, 0
	bg	%icc, .LL286
	nop
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	call	_ZNSs4_Rep10_M_destroyERKSaIcE, 0
	 nop
.LL286:
	return	%i7+8
	nop
.LLFE51:
.LLfe51:
	.size	_ZNSs4_Rep10_M_disposeERKSaIcE,.LLfe51-_ZNSs4_Rep10_M_disposeERKSaIcE
.section	".gnu.linkonce.t._ZNSaISt4pairIKSsiEEC1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSaISt4pairIKSsiEEC1Ev
	.type	_ZNSaISt4pairIKSsiEEC1Ev,#function
	.proc	020
_ZNSaISt4pairIKSsiEEC1Ev:
.LLFB52:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI51:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE52:
.LLfe52:
	.size	_ZNSaISt4pairIKSsiEEC1Ev,.LLfe52-_ZNSaISt4pairIKSsiEEC1Ev
.section	".gnu.linkonce.t._ZNSaISt4pairIKSsiEED1Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSaISt4pairIKSsiEED1Ev
	.type	_ZNSaISt4pairIKSsiEED1Ev,#function
	.proc	020
_ZNSaISt4pairIKSsiEED1Ev:
.LLFB53:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI52:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE53:
.LLfe53:
	.size	_ZNSaISt4pairIKSsiEED1Ev,.LLfe53-_ZNSaISt4pairIKSsiEED1Ev
.section	".gnu.linkonce.t._ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_
	.type	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_,#function
	.proc	020
_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_:
.LLFB54:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI53:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %l0
	mov	%i2, %o1
	ldx	[%fp+2175], %o0
.LLEHB52:
	call	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EEC2ERKS3_, 0
	 nop
.LLEHE52:
	ldx	[%fp+2175], %o0
	stx	%g0, [%o0+8]
	ldx	[%fp+2175], %o1
	add	%o1, 16, %o0
	mov	%l0, %o1
	call	_ZNSt4lessISsEC1ERKS0_, 0
	 nop
	ldx	[%fp+2175], %o0
.LLEHB53:
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE19_M_empty_initializeEv, 0
	 nop
.LLEHE53:
	ba,pt	%xcc, .LL294
	 nop
.LL299:
	stx	%i0, [%fp+2023]
	ldx	[%fp+2023], %l0
	ldx	[%fp+2175], %o0
	call	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EED2Ev, 0
	 nop
	stx	%l0, [%fp+2023]
	ldx	[%fp+2023], %o0
.LLEHB54:
	call	_Unwind_Resume, 0
	 nop
.LLEHE54:
.LL294:
	return	%i7+8
	nop
.LLFE54:
.LLfe54:
	.size	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_,.LLfe54-_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_
.section	".gcc_except_table",#alloc,#write
.LLLSDA54:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x27
	.uaword	.LLEHB52-.LLFB54
	.uaword	.LLEHE52-.LLEHB52
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB53-.LLFB54
	.uaword	.LLEHE53-.LLEHB53
	.uaword	.LL299-.LLFB54
	.byte	0x0
	.uaword	.LLEHB54-.LLFB54
	.uaword	.LLEHE54-.LLEHB54
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EEC1ERKS6_RKS7_",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EED2Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EED2Ev
	.type	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EED2Ev,#function
	.proc	020
_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EED2Ev:
.LLFB55:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI54:
	!#PROLOGUE# 1
	mov	%i0, %o1
	mov	%o1, %o0
	ldx	[%o1], %o1
	call	_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	return	%i7+8
	nop
.LLFE55:
.LLfe55:
	.size	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EED2Ev,.LLfe55-_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EED2Ev
.section	".gnu.linkonce.t._ZNSi6sentryC1ERSib",#alloc,#execinstr
	.align 4
	.weak	_ZNSi6sentryC1ERSib
	.type	_ZNSi6sentryC1ERSib,#function
	.proc	020
_ZNSi6sentryC1ERSib:
.LLFB56:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI55:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	mov	%i2, %o0
	stb	%o0, [%fp+2191]
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL303
	nop
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv, 0
	 nop
	brz	%o0, .LL304
	nop
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv, 0
	 nop
	call	_ZNSo5flushEv, 0
	 nop
.LL304:
	ldub	[%fp+2191], %o0
	cmp	%o0, 0
	bne	%icc, .LL303
	nop
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	add	%o0, 8, %o0
	call	_ZNKSt8ios_base5flagsEv, 0
	 nop
	sethi	%hi(4096), %o1
	call	_ZStanSt13_Ios_FmtflagsS_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL303
	nop
	call	_ZNSt11char_traitsIcE3eofEv, 0
	 nop
	st	%o0, [%fp+2027]
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv, 0
	 nop
	stx	%o0, [%fp+2015]
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	stx	%o0, [%fp+2007]
	ldx	[%fp+2007], %o0
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv, 0
	 nop
	st	%o0, [%fp+2003]
.LL306:
	ld	[%fp+2003], %o1
	ld	[%fp+2027], %o0
	cmp	%o1, %o0
	be	%icc, .LL307
	nop
	ldub	[%fp+2006], %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o2
	ldx	[%fp+2015], %o0
	mov	8, %o1
	call	_ZNKSt5ctypeIcE2isEjc, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL308
	nop
	ba,pt	%xcc, .LL307
	 nop
.LL308:
	ldx	[%fp+2007], %o0
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE6snextcEv, 0
	 nop
	st	%o0, [%fp+2003]
	ba,pt	%xcc, .LL306
	 nop
.LL307:
	ld	[%fp+2003], %o1
	ld	[%fp+2027], %o0
	cmp	%o1, %o0
	bne	%icc, .LL303
	nop
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	mov	2, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LL303:
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL311
	nop
	mov	1, %o0
	ldx	[%fp+2175], %o1
	stb	%o0, [%o1]
	ba,pt	%xcc, .LL302
	 nop
.LL311:
	ldx	[%fp+2175], %o0
	stb	%g0, [%o0]
	ldx	[%fp+2183], %o0
	ldx	[%o0], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	mov	4, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LL302:
	return	%i7+8
	nop
.LLFE56:
.LLfe56:
	.size	_ZNSi6sentryC1ERSib,.LLfe56-_ZNSi6sentryC1ERSib
.section	".gnu.linkonce.t._ZNSi6sentrycvbEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSi6sentrycvbEv
	.type	_ZNSi6sentrycvbEv,#function
	.proc	00
_ZNSi6sentrycvbEv:
.LLFB57:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI56:
	!#PROLOGUE# 1
	ldub	[%i0], %i0
	and	%i0, 0xff, %i0
	return	%i7+8
	nop
.LLFE57:
.LLfe57:
	.size	_ZNSi6sentrycvbEv,.LLfe57-_ZNSi6sentrycvbEv
	.weak	_ZNSs4nposE
.section	".gnu.linkonce.r._ZNSs4nposE",#alloc
	.align 8
	.type	_ZNSs4nposE,#object
	.size	_ZNSs4nposE,8
_ZNSs4nposE:
	.uaword	-1
	.uaword	-1
.section	".gnu.linkonce.t._ZNSs5eraseEmm",#alloc,#execinstr
	.align 4
	.weak	_ZNSs5eraseEmm
	.type	_ZNSs5eraseEmm,#function
	.proc	0110
_ZNSs5eraseEmm:
.LLFB58:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI57:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %l1
	mov	%i2, %l2
	mov	%l0, %o0
	mov	%l1, %o1
	call	_ZNKSs8_M_checkEm, 0
	 nop
	stx	%o0, [%fp+2023]
	mov	%l0, %o0
	mov	%l1, %o1
	mov	%l2, %o2
	call	_ZNKSs7_M_foldEmm, 0
	 nop
	stx	%o0, [%fp+2015]
	mov	%l0, %o0
	call	_ZNKSs7_M_dataEv, 0
	 nop
	mov	%o0, %l1
	mov	%l0, %o0
	call	_ZNKSs7_M_dataEv, 0
	 nop
	mov	%o0, %o4
	mov	%l0, %o0
	ldx	[%fp+2023], %o1
	ldx	[%fp+2015], %o2
	mov	%l1, %o3
	call	_ZNSs7replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE58:
.LLfe58:
	.size	_ZNSs5eraseEmm,.LLfe58-_ZNSs5eraseEmm
.section	".gnu.linkonce.t._ZNKSs8max_sizeEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs8max_sizeEv
	.type	_ZNKSs8max_sizeEv,#function
	.proc	017
_ZNKSs8max_sizeEv:
.LLFB59:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI58:
	!#PROLOGUE# 1
	sethi	%hh(_ZNSs4_Rep11_S_max_sizeE), %i0
	or	%i0, %hm(_ZNSs4_Rep11_S_max_sizeE), %i0
	sllx	%i0, 32, %i0
	sethi	%lm(_ZNSs4_Rep11_S_max_sizeE), %i1
	add	%i0, %i1, %i0
	or	%i0, %lo(_ZNSs4_Rep11_S_max_sizeE), %i0
	ldx	[%i0], %i0
	return	%i7+8
	nop
.LLFE59:
.LLfe59:
	.size	_ZNKSs8max_sizeEv,.LLfe59-_ZNKSs8max_sizeEv
.section	".gnu.linkonce.t._ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv
	.type	_ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv,#function
	.proc	0110
_ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv:
.LLFB60:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI59:
	!#PROLOGUE# 1
	ldx	[%i0+240], %i0
	return	%i7+8
	nop
.LLFE60:
.LLfe60:
	.size	_ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv,.LLfe60-_ZNSt9basic_iosIcSt11char_traitsIcEE17_M_get_fctype_iosEv
.section	".gnu.linkonce.t._ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv
	.type	_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv,#function
	.proc	04
_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv:
.LLFB61:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI60:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	ldx	[%fp+2175], %o1
	ldx	[%o1+40], %o0
	brz	%o0, .LL322
	nop
	ldx	[%fp+2175], %o2
	ldx	[%o2+40], %o1
	ldx	[%fp+2175], %o2
	ldx	[%o2+48], %o0
	cmp	%o1, %o0
	bgeu	%xcc, .LL322
	nop
	ldx	[%fp+2175], %o0
	call	_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv, 0
	 nop
	ldub	[%o0], %o0
	stb	%o0, [%fp+2026]
	ldx	[%fp+2175], %o0
	mov	1, %o1
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl, 0
	 nop
	add	%fp, 2026, %o0
	call	_ZNSt11char_traitsIcE11to_int_typeERKc, 0
	 nop
	st	%o0, [%fp+2027]
	ba,pt	%xcc, .LL323
	 nop
.LL322:
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, 80, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	call	%o1, 0
	 nop
	st	%o0, [%fp+2027]
.LL323:
	ldsw	[%fp+2027], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE61:
.LLfe61:
	.size	_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv,.LLfe61-_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv
.section	".gnu.linkonce.t._ZNSspLEc",#alloc,#execinstr
	.align 4
	.weak	_ZNSspLEc
	.type	_ZNSspLEc,#function
	.proc	0110
_ZNSspLEc:
.LLFB62:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI61:
	!#PROLOGUE# 1
	mov	%i0, %o1
	mov	%i1, %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o2
	mov	%o1, %o0
	mov	1, %o1
	call	_ZNSs6appendEmc, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE62:
.LLfe62:
	.size	_ZNSspLEc,.LLfe62-_ZNSspLEc
.section	".gnu.linkonce.t._ZNSt15basic_streambufIcSt11char_traitsIcEE9sputbackcEc",#alloc,#execinstr
	.align 4
	.weak	_ZNSt15basic_streambufIcSt11char_traitsIcEE9sputbackcEc
	.type	_ZNSt15basic_streambufIcSt11char_traitsIcEE9sputbackcEc,#function
	.proc	04
_ZNSt15basic_streambufIcSt11char_traitsIcEE9sputbackcEc:
.LLFB63:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI62:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %o0
	stb	%o0, [%fp+2183]
	stb	%g0, [%fp+2024]
	ldx	[%fp+2175], %o1
	ldx	[%o1+40], %o0
	brz	%o0, .LL328
	nop
	ldx	[%fp+2175], %o2
	ldx	[%o2+32], %o1
	ldx	[%fp+2175], %o2
	ldx	[%o2+40], %o0
	cmp	%o1, %o0
	bgeu	%xcc, .LL328
	nop
	mov	1, %o0
	stb	%o0, [%fp+2024]
.LL328:
	ldub	[%fp+2024], %o1
	stb	%o1, [%fp+2026]
	stb	%g0, [%fp+2023]
	ldx	[%fp+2175], %o2
	ldx	[%o2+40], %o0
	brz	%o0, .LL329
	nop
	ldx	[%fp+2175], %o0
	call	_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv, 0
	 nop
	add	%o0, -1, %o1
	add	%fp, 2183, %o0
	call	_ZNSt11char_traitsIcE2eqERKcS2_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL329
	nop
	mov	1, %o0
	stb	%o0, [%fp+2023]
.LL329:
	ldub	[%fp+2023], %o1
	stb	%o1, [%fp+2025]
	ldub	[%fp+2026], %o0
	cmp	%o0, 0
	be	%icc, .LL331
	nop
	ldub	[%fp+2025], %o0
	cmp	%o0, 0
	bne	%icc, .LL331
	nop
	ba,pt	%xcc, .LL330
	 nop
.LL331:
	add	%fp, 2183, %o0
	call	_ZNSt11char_traitsIcE11to_int_typeERKc, 0
	 nop
	mov	%o0, %o1
	ldx	[%fp+2175], %o2
	ldx	[%o2], %o0
	add	%o0, 88, %o0
	ldx	[%o0], %o2
	ldx	[%fp+2175], %o0
	call	%o2, 0
	 nop
	st	%o0, [%fp+2027]
	ba,pt	%xcc, .LL332
	 nop
.LL330:
	ldx	[%fp+2175], %o0
	mov	-1, %o1
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl, 0
	 nop
	ldx	[%fp+2175], %o0
	call	_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv, 0
	 nop
	call	_ZNSt11char_traitsIcE11to_int_typeERKc, 0
	 nop
	st	%o0, [%fp+2027]
.LL332:
	ldsw	[%fp+2027], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE63:
.LLfe63:
	.size	_ZNSt15basic_streambufIcSt11char_traitsIcEE9sputbackcEc,.LLfe63-_ZNSt15basic_streambufIcSt11char_traitsIcEE9sputbackcEc
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv,#function
	.proc	00
_ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv:
.LLFB64:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI63:
	!#PROLOGUE# 1
	mov	%i0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv, 0
	 nop
	mov	%o0, %l0
	mov	1, %o0
	mov	4, %o1
	call	_ZStorSt12_Ios_IostateS_, 0
	 nop
	mov	%o0, %o1
	mov	%l0, %o0
	call	_ZStanSt12_Ios_IostateS_, 0
	 nop
	xor	%o0, 0, %o0
	subcc	%g0, %o0, %g0
	addx	%g0, 0, %o0
	and	%o0, 0xff, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE64:
.LLfe64:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv,.LLfe64-_ZNKSt9basic_iosIcSt11char_traitsIcEE4failEv
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE11lower_boundERS3_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE11lower_boundERS3_
	.type	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE11lower_boundERS3_,#function
	.proc	010
_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE11lower_boundERS3_:
.LLFB65:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI64:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	mov	%i2, %o2
	mov	%l0, %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11lower_boundERS1_, 0
	 nop
	return	%i7+8
	nop
.LLFE65:
.LLfe65:
	.size	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE11lower_boundERS3_,.LLfe65-_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE11lower_boundERS3_
.section	".gnu.linkonce.t._ZSteqISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_",#alloc,#execinstr
	.align 4
	.weak	_ZSteqISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_
	.type	_ZSteqISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_,#function
	.proc	00
_ZSteqISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_:
.LLFB66:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI65:
	!#PROLOGUE# 1
	ldx	[%i0], %i2
	ldx	[%i1], %i0
	xor	%i2, %i0, %i0
	mov	0, %o0
	movre	%i0, 1, %o0
	mov	%o0, %i0
	and	%i0, 0xff, %i0
	return	%i7+8
	nop
.LLFE66:
.LLfe66:
	.size	_ZSteqISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_,.LLfe66-_ZSteqISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_
.section	".gnu.linkonce.t._ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv
	.type	_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv,#function
	.proc	0110
_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv:
.LLFB67:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI66:
	!#PROLOGUE# 1
	ldx	[%i0], %i0
	add	%i0, 32, %i0
	return	%i7+8
	nop
.LLFE67:
.LLfe67:
	.size	_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv,.LLfe67-_ZNKSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EdeEv
.section	".gnu.linkonce.t._ZNKSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE8key_compEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE8key_compEv
	.type	_ZNKSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE8key_compEv,#function
	.proc	010
_ZNKSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE8key_compEv:
.LLFB68:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI67:
	!#PROLOGUE# 1
	mov	%i0, %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8key_compEv, 0
	 nop
	mov	%o0, %o1
	srax	%o1, 56, %o1
	ldub	[%fp+2030], %o0
	and	%o0, 0, %o0
	mov	%o0, %o2
	mov	%o1, %o0
	or	%o2, %o0, %o0
	stb	%o0, [%fp+2030]
	ldub	[%fp+2030], %o0
	and	%o0, 0xff, %o0
	sllx	%o0, 56, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE68:
.LLfe68:
	.size	_ZNKSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE8key_compEv,.LLfe68-_ZNKSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE8key_compEv
.section	".gnu.linkonce.t._ZNKSt4lessISsEclERKSsS2_",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt4lessISsEclERKSsS2_
	.type	_ZNKSt4lessISsEclERKSsS2_,#function
	.proc	00
_ZNKSt4lessISsEclERKSsS2_:
.LLFB69:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI68:
	!#PROLOGUE# 1
	mov	%i1, %o0
	mov	%i2, %o1
	call	_ZStltIcSt11char_traitsIcESaIcEEbRKSbIT_T0_T1_ES8_, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE69:
.LLfe69:
	.size	_ZNKSt4lessISsEclERKSsS2_,.LLfe69-_ZNKSt4lessISsEclERKSsS2_
.section	".gnu.linkonce.t._ZNSt4pairIKSsiEC1ERS0_RKi",#alloc,#execinstr
	.align 4
	.weak	_ZNSt4pairIKSsiEC1ERS0_RKi
	.type	_ZNSt4pairIKSsiEC1ERS0_RKi,#function
	.proc	020
_ZNSt4pairIKSsiEC1ERS0_RKi:
.LLFB70:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI69:
	!#PROLOGUE# 1
	mov	%i0, %l1
	mov	%i1, %o1
	mov	%i2, %l0
	mov	%l1, %o0
	call	_ZNSsC1ERKSs, 0
	 nop
	ld	[%l0], %o0
	st	%o0, [%l1+8]
	return	%i7+8
	nop
.LLFE70:
.LLfe70:
	.size	_ZNSt4pairIKSsiEC1ERS0_RKi,.LLfe70-_ZNSt4pairIKSsiEC1ERS0_RKi
.section	".gnu.linkonce.t._ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE6insertESt17_Rb_tree_iteratorIS4_RS4_PS4_ERKS4_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE6insertESt17_Rb_tree_iteratorIS4_RS4_PS4_ERKS4_
	.type	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE6insertESt17_Rb_tree_iteratorIS4_RS4_PS4_ERKS4_,#function
	.proc	010
_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE6insertESt17_Rb_tree_iteratorIS4_RS4_PS4_ERKS4_:
.LLFB71:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI70:
	!#PROLOGUE# 1
	mov	%i0, %l2
	mov	%i1, %l0
	mov	%i2, %o1
	mov	%i3, %l1
	add	%fp, 2015, %o0
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_, 0
	 nop
	mov	%l2, %o0
	mov	%l0, %o1
	add	%fp, 2015, %o2
	mov	%l1, %o3
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueESt17_Rb_tree_iteratorIS2_RS2_PS2_ERKS2_, 0
	 nop
	return	%i7+8
	nop
.LLFE71:
.LLfe71:
	.size	_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE6insertESt17_Rb_tree_iteratorIS4_RS4_PS4_ERKS4_,.LLfe71-_ZNSt3mapISsiSt4lessISsESaISt4pairIKSsiEEE6insertESt17_Rb_tree_iteratorIS4_RS4_PS4_ERKS4_
.section	".gnu.linkonce.t._ZNSt12_Vector_baseISt4pairIiSsESaIS1_EEC2ERKS2_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EEC2ERKS2_
	.type	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EEC2ERKS2_,#function
	.proc	020
_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EEC2ERKS2_:
.LLFB72:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI71:
	!#PROLOGUE# 1
	mov	%i0, %o0
	mov	%i1, %o1
	call	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EEC2ERKS2_, 0
	 nop
	return	%i7+8
	nop
.LLFE72:
.LLfe72:
	.size	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EEC2ERKS2_,.LLfe72-_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EEC2ERKS2_
.section	".gnu.linkonce.t._ZNSt12_Vector_baseISt4pairIiSsESaIS1_EED2Ev",#alloc,#execinstr
	.align 4
	.weak	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EED2Ev
	.type	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EED2Ev,#function
	.proc	020
_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EED2Ev:
.LLFB73:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI72:
	!#PROLOGUE# 1
	mov	%i0, %o1
	ldx	[%o1+16], %o2
	ldx	[%o1], %o0
	sub	%o2, %o0, %o0
	sdivx	%o0, 16, %o2
	mov	%o1, %o0
	ldx	[%o1], %o1
	call	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EE13_M_deallocateEPS1_m, 0
	 nop
	return	%i7+8
	nop
.LLFE73:
.LLfe73:
	.size	_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EED2Ev,.LLfe73-_ZNSt12_Vector_baseISt4pairIiSsESaIS1_EED2Ev
.section	".gnu.linkonce.t._ZSt7destroyIPSt4pairIiSsEEvT_S3_",#alloc,#execinstr
	.align 4
	.weak	_ZSt7destroyIPSt4pairIiSsEEvT_S3_
	.type	_ZSt7destroyIPSt4pairIiSsEEvT_S3_,#function
	.proc	020
_ZSt7destroyIPSt4pairIiSsEEvT_S3_:
.LLFB74:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI73:
	!#PROLOGUE# 1
	mov	%i0, %o0
	mov	%i1, %o1
	call	_ZSt8_DestroyIPSt4pairIiSsEEvT_S3_, 0
	 nop
	return	%i7+8
	nop
.LLFE74:
.LLfe74:
	.size	_ZSt7destroyIPSt4pairIiSsEEvT_S3_,.LLfe74-_ZSt7destroyIPSt4pairIiSsEEvT_S3_
.section	".gnu.linkonce.t._ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE5beginEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE5beginEv
	.type	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE5beginEv,#function
	.proc	010
_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE5beginEv:
.LLFB75:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI74:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv, 0
	 nop
	mov	%o0, %o1
	mov	%l0, %o0
	ldx	[%o1], %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	return	%i7+8
	nop
.LLFE75:
.LLfe75:
	.size	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE5beginEv,.LLfe75-_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE5beginEv
.section	".gnu.linkonce.t._ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE3endEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE3endEv
	.type	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE3endEv,#function
	.proc	010
_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE3endEv:
.LLFB76:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI75:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	mov	%l0, %o0
	ldx	[%o1], %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	return	%i7+8
	nop
.LLFE76:
.LLfe76:
	.size	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE3endEv,.LLfe76-_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE3endEv
.section	".gnu.linkonce.t._ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEC1ERS4_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEC1ERS4_
	.type	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEC1ERS4_,#function
	.proc	020
_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEC1ERS4_:
.LLFB77:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI76:
	!#PROLOGUE# 1
	mov	%i0, %i2
	mov	%i1, %i0
	stx	%i0, [%i2]
	return	%i7+8
	nop
.LLFE77:
.LLfe77:
	.size	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEC1ERS4_,.LLfe77-_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEC1ERS4_
.section	".gnu.linkonce.t._ZStneISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_",#alloc,#execinstr
	.align 4
	.weak	_ZStneISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_
	.type	_ZStneISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_,#function
	.proc	00
_ZStneISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_:
.LLFB78:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI77:
	!#PROLOGUE# 1
	ldx	[%i0], %i2
	ldx	[%i1], %i0
	xor	%i2, %i0, %i0
	mov	0, %o0
	movrne	%i0, 1, %o0
	mov	%o0, %i0
	and	%i0, 0xff, %i0
	return	%i7+8
	nop
.LLFE78:
.LLfe78:
	.size	_ZStneISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_,.LLfe78-_ZStneISt4pairIKSsiERS2_PS2_EbRKSt17_Rb_tree_iteratorIT_T0_T1_ESB_
.section	".gnu.linkonce.t._ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EppEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EppEv
	.type	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EppEv,#function
	.proc	0110
_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EppEv:
.LLFB79:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI78:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%l0, %o0
	call	_ZNSt22_Rb_tree_base_iterator12_M_incrementEv, 0
	 nop
	return	%i7+8
	nop
.LLFE79:
.LLfe79:
	.size	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EppEv,.LLfe79-_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EppEv
.section	".gnu.linkonce.t._ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEppEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEppEv
	.type	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEppEv,#function
	.proc	0110
_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEppEv:
.LLFB80:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI79:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE80:
.LLfe80:
	.size	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEppEv,.LLfe80-_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEppEv
.section	".gnu.linkonce.t._ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEdeEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEdeEv
	.type	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEdeEv,#function
	.proc	0110
_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEdeEv:
.LLFB81:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI80:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE81:
.LLfe81:
	.size	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEdeEv,.LLfe81-_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEdeEv
.section	".gnu.linkonce.t._ZNSt4pairISsiEC1IKSsiEERKS_IT_T0_E",#alloc,#execinstr
	.align 4
	.weak	_ZNSt4pairISsiEC1IKSsiEERKS_IT_T0_E
	.type	_ZNSt4pairISsiEC1IKSsiEERKS_IT_T0_E,#function
	.proc	020
_ZNSt4pairISsiEC1IKSsiEERKS_IT_T0_E:
.LLFB82:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI81:
	!#PROLOGUE# 1
	mov	%i0, %l1
	mov	%i1, %l0
	mov	%l1, %o0
	mov	%l0, %o1
	call	_ZNSsC1ERKSs, 0
	 nop
	ld	[%l0+8], %o0
	st	%o0, [%l1+8]
	return	%i7+8
	nop
.LLFE82:
.LLfe82:
	.size	_ZNSt4pairISsiEC1IKSsiEERKS_IT_T0_E,.LLfe82-_ZNSt4pairISsiEC1IKSsiEERKS_IT_T0_E
.section	".gnu.linkonce.t._ZNSsC1ERKSs",#alloc,#execinstr
	.align 4
	.weak	_ZNSsC1ERKSs
	.type	_ZNSsC1ERKSs,#function
	.proc	020
_ZNSsC1ERKSs:
.LLFB83:
	!#PROLOGUE# 0
	save	%sp, -272, %sp
.LLCFI82:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2183], %o0
.LLEHB55:
	call	_ZNKSs6_M_repEv, 0
	 nop
.LLEHE55:
	mov	%o0, %l0
	add	%fp, 2015, %o0
	call	_ZNSaIcEC1Ev, 0
	 nop
	add	%fp, 1999, %o0
	ldx	[%fp+2183], %o1
	call	_ZNKSs13get_allocatorEv, 0
	 nop
	mov	%l0, %o0
	add	%fp, 2015, %o1
	add	%fp, 1999, %o2
.LLEHB56:
	call	_ZNSs4_Rep7_M_grabERKSaIcES2_, 0
	 nop
.LLEHE56:
	mov	%o0, %l0
	add	%fp, 1983, %o0
	ldx	[%fp+2183], %o1
	call	_ZNKSs13get_allocatorEv, 0
	 nop
	ldx	[%fp+2175], %o0
	mov	%l0, %o1
	add	%fp, 1983, %o2
	call	_ZNSs12_Alloc_hiderC1EPcRKSaIcE, 0
	 nop
	add	%fp, 1983, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	add	%fp, 1999, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	ba,pt	%xcc, .LL386
	 nop
.LL393:
	stx	%i0, [%fp+1975]
	ldx	[%fp+1975], %l0
	add	%fp, 1999, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	stx	%l0, [%fp+1975]
.LL394:
	ldx	[%fp+1975], %l0
	add	%fp, 2015, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	stx	%l0, [%fp+1975]
	ldx	[%fp+1975], %o0
.LLEHB57:
	call	_Unwind_Resume, 0
	 nop
.LLEHE57:
.LL386:
	add	%fp, 2015, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	return	%i7+8
	nop
.LLFE83:
.LLfe83:
	.size	_ZNSsC1ERKSs,.LLfe83-_ZNSsC1ERKSs
.section	".gcc_except_table",#alloc,#write
.LLLSDA83:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x27
	.uaword	.LLEHB55-.LLFB83
	.uaword	.LLEHE55-.LLEHB55
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB56-.LLFB83
	.uaword	.LLEHE56-.LLEHB56
	.uaword	.LL393-.LLFB83
	.byte	0x0
	.uaword	.LLEHB57-.LLFB83
	.uaword	.LLEHE57-.LLEHB57
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSsC1ERKSs",#alloc,#execinstr
.section	".gnu.linkonce.t._ZN5pswapISsiEclERKSt4pairISsiE",#alloc,#execinstr
	.align 4
	.weak	_ZN5pswapISsiEclERKSt4pairISsiE
	.type	_ZN5pswapISsiEclERKSt4pairISsiE,#function
	.proc	010
_ZN5pswapISsiEclERKSt4pairISsiE:
.LLFB84:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI83:
	!#PROLOGUE# 1
	mov	%i0, %l1
	mov	%i2, %l0
	add	%fp, 2015, %o0
	mov	%l0, %o1
	call	_ZNSsC1ERKSs, 0
	 nop
	ld	[%l0+8], %o0
	sra	%o0, 0, %o1
	mov	%l1, %o0
	add	%fp, 2015, %o2
	call	_ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_, 0
	 nop
	return	%i7+8
	nop
.LLFE84:
.LLfe84:
	.size	_ZN5pswapISsiEclERKSt4pairISsiE,.LLfe84-_ZN5pswapISsiEclERKSt4pairISsiE
.section	".gnu.linkonce.t._ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEaSERKS2_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEaSERKS2_
	.type	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEaSERKS2_,#function
	.proc	0110
_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEaSERKS2_:
.LLFB85:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI84:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	ldx	[%l0], %o0
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EE9push_backERKS1_, 0
	 nop
	return	%i7+8
	nop
.LLFE85:
.LLfe85:
	.size	_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEaSERKS2_,.LLfe85-_ZNSt20back_insert_iteratorISt6vectorISt4pairIiSsESaIS2_EEEaSERKS2_
.section	".gnu.linkonce.t._ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_
	.type	_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_,#function
	.proc	020
_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_:
.LLFB86:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI85:
	!#PROLOGUE# 1
	ldx	[%i1], %i1
	stx	%i1, [%i0]
	return	%i7+8
	nop
.LLFE86:
.LLfe86:
	.size	_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_,.LLfe86-_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_
.section	".gnu.linkonce.t._ZStneIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E",#alloc,#execinstr
	.align 4
	.weak	_ZStneIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E
	.type	_ZStneIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E,#function
	.proc	00
_ZStneIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E:
.LLFB87:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI86:
	!#PROLOGUE# 1
	mov	%i0, %o0
	mov	%i1, %o1
	call	_ZSteqIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E, 0
	 nop
	xor	%o0, 1, %o0
	and	%o0, 0xff, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE87:
.LLfe87:
	.size	_ZStneIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E,.LLfe87-_ZStneIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E
.section	".gnu.linkonce.t._ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_",#alloc,#execinstr
	.align 4
	.weak	_ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_
	.type	_ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_,#function
	.proc	0110
_ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_:
.LLFB88:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI87:
	!#PROLOGUE# 1
	mov	0, %i0
	return	%i7+8
	nop
.LLFE88:
.LLfe88:
	.size	_ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_,.LLfe88-_ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_
.section	".gnu.linkonce.t._ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_
	.type	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_,#function
	.proc	05
_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_:
.LLFB89:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI88:
	!#PROLOGUE# 1
	ldx	[%i0], %i2
	ldx	[%i1], %i0
	sub	%i2, %i0, %i0
	sdivx	%i0, 16, %i0
	return	%i7+8
	nop
.LLFE89:
.LLfe89:
	.size	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_,.LLfe89-_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_
.section	".gnu.linkonce.t._ZSt4__lgIlET_S0_",#alloc,#execinstr
	.align 4
	.weak	_ZSt4__lgIlET_S0_
	.type	_ZSt4__lgIlET_S0_,#function
	.proc	05
_ZSt4__lgIlET_S0_:
.LLFB90:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI89:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%g0, [%fp+2023]
.LL407:
	ldx	[%fp+2175], %o0
	cmp	%o0, 1
	bne	%xcc, .LL410
	nop
	ba,pt	%xcc, .LL408
	 nop
.LL410:
	ldx	[%fp+2023], %i0
	add	%i0, 1, %i0
	stx	%i0, [%fp+2023]
	ldx	[%fp+2175], %o0
	srax	%o0, 1, %o0
	stx	%o0, [%fp+2175]
	ba,pt	%xcc, .LL407
	 nop
.LL408:
	ldx	[%fp+2023], %i0
	return	%i7+8
	nop
.LLFE90:
.LLfe90:
	.size	_ZSt4__lgIlET_S0_,.LLfe90-_ZSt4__lgIlET_S0_
.section	".gnu.linkonce.t._ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_",#alloc,#execinstr
	.align 4
	.weak	_ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_
	.type	_ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_,#function
	.proc	020
_ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_:
.LLFB91:
	!#PROLOGUE# 0
	save	%sp, -256, %sp
.LLCFI90:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	stx	%i3, [%fp+2199]
.LL413:
	add	%fp, 2183, %o0
	add	%fp, 2175, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_, 0
	 nop
	cmp	%o0, 16
	bg	%xcc, .LL415
	nop
	ba,pt	%xcc, .LL417
	 nop
.LL415:
	ldx	[%fp+2199], %o0
	brnz	%o0, .LL416
	nop
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2183], %o2
	call	_ZSt12partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_S8_, 0
	 nop
	ba,pt	%xcc, .LL412
	 nop
.LL416:
	ldx	[%fp+2199], %o0
	add	%o0, -1, %o0
	stx	%o0, [%fp+2199]
	add	%fp, 2175, %o0
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv, 0
	 nop
	mov	%o0, %l1
	add	%fp, 2183, %o0
	add	%fp, 2175, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_, 0
	 nop
	mov	%o0, %o1
	srax	%o1, 63, %o0
	srlx	%o0, 63, %o0
	add	%o1, %o0, %o0
	srax	%o0, 1, %o0
	stx	%o0, [%fp+1983]
	add	%fp, 2175, %o0
	add	%fp, 1983, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl, 0
	 nop
	stx	%o0, [%fp+1991]
	add	%fp, 1991, %o0
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv, 0
	 nop
	mov	%o0, %l0
	mov	1, %o0
	stx	%o0, [%fp+1967]
	add	%fp, 2183, %o0
	add	%fp, 1967, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKl, 0
	 nop
	stx	%o0, [%fp+1975]
	add	%fp, 1975, %o0
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv, 0
	 nop
	mov	%o0, %o2
	mov	%l1, %o0
	mov	%l0, %o1
	call	_ZSt8__medianISt4pairIiSsEERKT_S4_S4_S4_, 0
	 nop
	mov	%o0, %o1
	add	%fp, 1999, %o0
	call	_ZNSt4pairIiSsEC1ERKS0_, 0
	 nop
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	add	%fp, 1999, %o2
	call	_ZSt21__unguarded_partitionISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_ET_S8_S8_T0_, 0
	 nop
	stx	%o0, [%fp+2023]
	ldx	[%fp+2023], %o0
	stx	%o0, [%fp+2023]
	ldx	[%fp+2023], %o0
	ldx	[%fp+2183], %o1
	mov	0, %o2
	ldx	[%fp+2199], %o3
	call	_ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_, 0
	 nop
	ldx	[%fp+2023], %o0
	stx	%o0, [%fp+2183]
	ba,pt	%xcc, .LL413
	 nop
.LL417:
.LL412:
	return	%i7+8
	nop
.LLFE91:
.LLfe91:
	.size	_ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_,.LLfe91-_ZSt16__introsort_loopISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_lEvT_S8_PT0_T1_
.section	".gnu.linkonce.t._ZSt22__final_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_",#alloc,#execinstr
	.align 4
	.weak	_ZSt22__final_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_
	.type	_ZSt22__final_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_,#function
	.proc	020
_ZSt22__final_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_:
.LLFB92:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI91:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	add	%fp, 2183, %o0
	add	%fp, 2175, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKS6_, 0
	 nop
	cmp	%o0, 16
	ble	%xcc, .LL419
	nop
	mov	16, %o0
	stx	%o0, [%fp+2015]
	add	%fp, 2175, %o0
	add	%fp, 2015, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl, 0
	 nop
	stx	%o0, [%fp+2023]
	ldx	[%fp+2175], %o0
	ldx	[%fp+2023], %o1
	call	_ZSt16__insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_, 0
	 nop
	mov	16, %o0
	stx	%o0, [%fp+1999]
	add	%fp, 2175, %o0
	add	%fp, 1999, %o1
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl, 0
	 nop
	stx	%o0, [%fp+2007]
	ldx	[%fp+2007], %o0
	ldx	[%fp+2183], %o1
	call	_ZSt26__unguarded_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_, 0
	 nop
	ba,pt	%xcc, .LL421
	 nop
.LL419:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	call	_ZSt16__insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_, 0
	 nop
.LL421:
	return	%i7+8
	nop
.LLFE92:
.LLfe92:
	.size	_ZSt22__final_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_,.LLfe92-_ZSt22__final_insertion_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_
.section	".gnu.linkonce.t._ZSt10__copy_ni1ISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_5_BoolILb1EE",#alloc,#execinstr
	.align 4
	.weak	_ZSt10__copy_ni1ISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_5_BoolILb1EE
	.type	_ZSt10__copy_ni1ISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_5_BoolILb1EE,#function
	.proc	010
_ZSt10__copy_ni1ISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_5_BoolILb1EE:
.LLFB93:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI92:
	!#PROLOGUE# 1
	mov	%i0, %l1
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	mov	%i3, %o3
	mov	%i4, %o1
	srax	%o1, 56, %o1
	ldub	[%fp+2207], %o0
	and	%o0, 0, %o0
	mov	%o0, %o2
	mov	%o1, %o0
	or	%o2, %o0, %o0
	stb	%o0, [%fp+2207]
	ldx	[%o3], %o0
	stx	%o0, [%fp+2015]
	ldx	[%o3+8], %o0
	stx	%o0, [%fp+2023]
	add	%fp, 2183, %o0
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEE4baseEv, 0
	 nop
	mov	%o0, %l0
	add	%fp, 2191, %o0
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEE4baseEv, 0
	 nop
	mov	%o0, %o2
	stb	%g0, [%fp+2014]
	mov	%l1, %o0
	ldx	[%l0], %o1
	ldx	[%o2], %o2
	add	%fp, 2015, %o3
	mov	0, %o4
	call	_ZSt10__copy_ni2IPSt4pairIiSsESt16ostream_iteratorIS1_cSt11char_traitsIcEEET0_T_S8_S7_5_BoolILb0EE, 0
	 nop
	return	%i7+8
	nop
.LLFE93:
.LLfe93:
	.size	_ZSt10__copy_ni1ISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_5_BoolILb1EE,.LLfe93-_ZSt10__copy_ni1ISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEESt16ostream_iteratorIS2_cSt11char_traitsIcEEET0_T_SD_SC_5_BoolILb1EE
.section	".gnu.linkonce.t._ZNKSs7_M_dataEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs7_M_dataEv
	.type	_ZNKSs7_M_dataEv,#function
	.proc	0102
_ZNKSs7_M_dataEv:
.LLFB94:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI93:
	!#PROLOGUE# 1
	ldx	[%i0], %i0
	return	%i7+8
	nop
.LLFE94:
.LLfe94:
	.size	_ZNKSs7_M_dataEv,.LLfe94-_ZNKSs7_M_dataEv
.section	".gnu.linkonce.t._ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE",#alloc,#execinstr
	.align 4
	.weak	_ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE
	.type	_ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE,#function
	.proc	00
_ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE:
.LLFB95:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI94:
	!#PROLOGUE# 1
	mov	%i1, %o0
	stb	%g0, [%fp+2030]
	brz	%o0, .LL427
	nop
	mov	1, %o0
	stb	%o0, [%fp+2030]
	ba,pt	%xcc, .LL428
	 nop
.LL427:
	call	_ZSt16__throw_bad_castv, 0
	 nop
.LL428:
	ldub	[%fp+2030], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE95:
.LLfe95:
	.size	_ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE,.LLfe95-_ZNSt9basic_iosIcSt11char_traitsIcEE14_M_check_facetEPKNSt6locale5facetE
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv,#function
	.proc	02
_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv:
.LLFB96:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI95:
	!#PROLOGUE# 1
	ldub	[%i0+216], %i0
	sllx	%i0, 56, %i0
	srax	%i0, 56, %i0
	return	%i7+8
	nop
.LLFE96:
.LLfe96:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv,.LLfe96-_ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv
.section	".gnu.linkonce.t._ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo",#alloc,#execinstr
	.align 4
	.weak	_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo
	.type	_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo,#function
	.proc	020
_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo:
.LLFB97:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI96:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	add	%o1, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	stx	%o0, [%l0]
	ldx	[%l0], %o0
	xor	%o0, 0, %o0
	mov	0, %o1
	movre	%o0, 1, %o1
	mov	%o1, %o0
	stb	%o0, [%l0+8]
	return	%i7+8
	nop
.LLFE97:
.LLfe97:
	.size	_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo,.LLfe97-_ZNSt19ostreambuf_iteratorIcSt11char_traitsIcEEC1ERSo
.section	".gnu.linkonce.t._ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm
	.type	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm,#function
	.proc	010
_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm:
.LLFB98:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI97:
	!#PROLOGUE# 1
	mov	%i0, %l1
	mov	%i1, %o3
	mov	%i2, %o1
	mov	%i3, %o5
	mov	%i4, %o0
	mov	%i5, %o7
	mov	%o0, %o2
	ldx	[%o1], %o0
	stx	%o0, [%fp+2015]
	ldx	[%o1+8], %o0
	stx	%o0, [%fp+2023]
	ldx	[%o3], %o0
	add	%o0, 32, %o1
	sllx	%o2, 56, %o0
	srax	%o0, 56, %o4
	ldx	[%o1], %l0
	mov	%l1, %o0
	mov	%o3, %o1
	add	%fp, 2015, %o2
	mov	%o5, %o3
	mov	%o7, %o5
	call	%l0, 0
	 nop
	return	%i7+8
	nop
.LLFE98:
.LLfe98:
	.size	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm,.LLfe98-_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecm
.section	".gnu.linkonce.t._ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv
	.type	_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv,#function
	.proc	00
_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv:
.LLFB99:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI98:
	!#PROLOGUE# 1
	ldub	[%i0+8], %i0
	and	%i0, 0xff, %i0
	return	%i7+8
	nop
.LLFE99:
.LLfe99:
	.size	_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv,.LLfe99-_ZNKSt19ostreambuf_iteratorIcSt11char_traitsIcEE6failedEv
.section	".gnu.linkonce.t._ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecl",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecl
	.type	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecl,#function
	.proc	010
_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecl:
.LLFB100:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI99:
	!#PROLOGUE# 1
	mov	%i0, %l1
	mov	%i1, %o3
	mov	%i2, %o1
	mov	%i3, %o5
	mov	%i4, %o0
	mov	%i5, %o7
	mov	%o0, %o2
	ldx	[%o1], %o0
	stx	%o0, [%fp+2015]
	ldx	[%o1+8], %o0
	stx	%o0, [%fp+2023]
	ldx	[%o3], %o0
	add	%o0, 24, %o1
	sllx	%o2, 56, %o0
	srax	%o0, 56, %o4
	ldx	[%o1], %l0
	mov	%l1, %o0
	mov	%o3, %o1
	add	%fp, 2015, %o2
	mov	%o5, %o3
	mov	%o7, %o5
	call	%l0, 0
	 nop
	return	%i7+8
	nop
.LLFE100:
.LLfe100:
	.size	_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecl,.LLfe100-_ZNKSt7num_putIcSt19ostreambuf_iteratorIcSt11char_traitsIcEEE3putES3_RSt8ios_basecl
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv,#function
	.proc	00
_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv:
.LLFB101:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI100:
	!#PROLOGUE# 1
	mov	%i0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv, 0
	 nop
	xor	%o0, 0, %o0
	subcc	%g0, %o0, %g0
	subx	%g0, -1, %o0
	and	%o0, 0xff, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE101:
.LLfe101:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv,.LLfe101-_ZNKSt9basic_iosIcSt11char_traitsIcEE4goodEv
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv,#function
	.proc	0110
_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv:
.LLFB102:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI101:
	!#PROLOGUE# 1
	ldx	[%i0+208], %i0
	return	%i7+8
	nop
.LLFE102:
.LLfe102:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv,.LLfe102-_ZNKSt9basic_iosIcSt11char_traitsIcEE3tieEv
.section	".gnu.linkonce.t._ZNSo5flushEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSo5flushEv
	.type	_ZNSo5flushEv,#function
	.proc	0110
_ZNSo5flushEv:
.LLFB103:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI102:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	add	%fp, 2015, %o0
	ldx	[%fp+2175], %o1
.LLEHB58:
	call	_ZNSo6sentryC1ERSo, 0
	 nop
.LLEHE58:
	add	%fp, 2015, %o0
	call	_ZNSo6sentrycvbEv, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL448
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	brz	%o0, .LL448
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
.LLEHB59:
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv, 0
	 nop
	cmp	%o0, -1
	bne	%icc, .LL448
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, -24, %o0
	ldx	[%o0], %o0
	ldx	[%fp+2175], %o1
	add	%o1, %o0, %o0
	mov	1, %o1
	call	_ZNSt9basic_iosIcSt11char_traitsIcEE8setstateESt12_Ios_Iostate, 0
	 nop
.LLEHE59:
.LL448:
	add	%fp, 2015, %o0
.LLEHB60:
	call	_ZNSo6sentryD1Ev, 0
	 nop
.LLEHE60:
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL447
	 nop
.LL455:
	stx	%i0, [%fp+2007]
	ldx	[%fp+2007], %l0
	add	%fp, 2015, %o0
	call	_ZNSo6sentryD1Ev, 0
	 nop
	stx	%l0, [%fp+2007]
	ldx	[%fp+2007], %o0
.LLEHB61:
	call	_Unwind_Resume, 0
	 nop
.LLEHE61:
.LL447:
	return	%i7+8
	nop
.LLFE103:
.LLfe103:
	.size	_ZNSo5flushEv,.LLfe103-_ZNSo5flushEv
.section	".gcc_except_table",#alloc,#write
.LLLSDA103:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x34
	.uaword	.LLEHB58-.LLFB103
	.uaword	.LLEHE58-.LLEHB58
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB59-.LLFB103
	.uaword	.LLEHE59-.LLEHB59
	.uaword	.LL455-.LLFB103
	.byte	0x0
	.uaword	.LLEHB60-.LLFB103
	.uaword	.LLEHE60-.LLEHB60
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB61-.LLFB103
	.uaword	.LLEHE61-.LLEHB61
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSo5flushEv",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv
	.type	_ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv,#function
	.proc	04
_ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv:
.LLFB104:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI103:
	!#PROLOGUE# 1
	mov	%i0, %o2
	ldx	[%o2], %o0
	add	%o0, 48, %o0
	ldx	[%o0], %o1
	mov	%o2, %o0
	call	%o1, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE104:
.LLfe104:
	.size	_ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv,.LLfe104-_ZNSt15basic_streambufIcSt11char_traitsIcEE7pubsyncEv
.section	".gnu.linkonce.t._ZNSt13_Format_cacheIcE6_S_getERSt8ios_base",#alloc,#execinstr
	.align 4
	.weak	_ZNSt13_Format_cacheIcE6_S_getERSt8ios_base
	.type	_ZNSt13_Format_cacheIcE6_S_getERSt8ios_base,#function
	.proc	0110
_ZNSt13_Format_cacheIcE6_S_getERSt8ios_base:
.LLFB105:
	!#PROLOGUE# 0
	save	%sp, -288, %sp
.LLCFI104:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	sethi	%hh(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	or	%o0, %hm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	sllx	%o0, 32, %o0
	sethi	%lm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o1
	add	%o0, %o1, %o0
	or	%o0, %lo(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	ld	[%o0], %o0
	cmp	%o0, 0
	bne	%icc, .LL459
	nop
	call	_ZNSt8ios_base6xallocEv, 0
	 nop
	sethi	%hh(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o1
	or	%o1, %hm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o1
	sllx	%o1, 32, %o1
	sethi	%lm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o2
	add	%o1, %o2, %o1
	or	%o1, %lo(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o1
	st	%o0, [%o1]
.LL459:
	stx	%g0, [%fp+2023]
	sethi	%hh(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	or	%o0, %hm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	sllx	%o0, 32, %o0
	sethi	%lm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o1
	add	%o0, %o1, %o0
	or	%o0, %lo(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	ld	[%o0], %o0
	sra	%o0, 0, %o1
	ldx	[%fp+2175], %o0
.LLEHB62:
	call	_ZNSt8ios_base5pwordEi, 0
	 nop
	stx	%o0, [%fp+2023]
	ldx	[%fp+2023], %o0
	ldx	[%o0], %o0
	brnz	%o0, .LL460
	nop
	mov	40, %o0
	call	_Znwm, 0
	 nop
.LLEHE62:
	stx	%o0, [%fp+1983]
	mov	1, %o0
	stb	%o0, [%fp+1982]
	ldx	[%fp+1983], %o0
.LLEHB63:
	call	_ZNSt13_Format_cacheIcEC1Ev, 0
	 nop
.LLEHE63:
	stb	%g0, [%fp+1982]
	add	%fp, 1999, %o0
	ldx	[%fp+1983], %o1
	call	_ZNSt8auto_ptrISt13_Format_cacheIcEEC1EPS1_, 0
	 nop
	ba,pt	%xcc, .LL462
	 nop
.LL476:
	stx	%i0, [%fp+1959]
	ldx	[%fp+1959], %o0
	stx	%o0, [%fp+1967]
	ldub	[%fp+1982], %o0
	cmp	%o0, 0
	be	%icc, .LL464
	nop
	ldx	[%fp+1983], %o0
	call	_ZdlPv, 0
	 nop
.LL464:
	ldx	[%fp+1967], %o0
	stx	%o0, [%fp+1959]
	ldx	[%fp+1959], %o0
.LLEHB64:
	call	_Unwind_Resume, 0
	 nop
.LLEHE64:
.LL462:
	ldub	[%fp+1982], %o0
	cmp	%o0, 0
	be	%icc, .LL468
	nop
	ldx	[%fp+1983], %o0
	call	_ZdlPv, 0
	 nop
.LL468:
	sethi	%hh(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	or	%o0, %hm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	sllx	%o0, 32, %o0
	sethi	%lm(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o1
	add	%o0, %o1, %o0
	or	%o0, %lo(_ZNSt13_Format_cacheIcE11_S_pword_ixE), %o0
	ld	[%o0], %o0
	sra	%o0, 0, %o3
	ldx	[%fp+2175], %o0
	sethi	%hh(_ZNSt13_Format_cacheIcE11_S_callbackENSt8ios_base5eventERS1_i), %o1
	or	%o1, %hm(_ZNSt13_Format_cacheIcE11_S_callbackENSt8ios_base5eventERS1_i), %o1
	sllx	%o1, 32, %o1
	sethi	%lm(_ZNSt13_Format_cacheIcE11_S_callbackENSt8ios_base5eventERS1_i), %o2
	add	%o1, %o2, %o1
	or	%o1, %lo(_ZNSt13_Format_cacheIcE11_S_callbackENSt8ios_base5eventERS1_i), %o1
	mov	%o3, %o2
.LLEHB65:
	call	_ZNSt8ios_base17register_callbackEPFvNS_5eventERS_iEi, 0
	 nop
.LLEHE65:
	ldx	[%fp+2023], %l0
	add	%fp, 1999, %o0
	call	_ZNSt8auto_ptrISt13_Format_cacheIcEE7releaseEv, 0
	 nop
	stx	%o0, [%l0]
	ba,pt	%xcc, .LL470
	 nop
.LL475:
	stx	%i0, [%fp+1959]
	ldx	[%fp+1959], %l0
	add	%fp, 1999, %o0
	call	_ZNSt8auto_ptrISt13_Format_cacheIcEED1Ev, 0
	 nop
	stx	%l0, [%fp+1959]
	ldx	[%fp+1959], %o0
.LLEHB66:
	call	_Unwind_Resume, 0
	 nop
.LL470:
	add	%fp, 1999, %o0
	call	_ZNSt8auto_ptrISt13_Format_cacheIcEED1Ev, 0
	 nop
.LL460:
	ldx	[%fp+2023], %o0
	ldx	[%o0], %o0
	stx	%o0, [%fp+1991]
	ldx	[%fp+1991], %o0
	ldub	[%o0], %o0
	and	%o0, 0xff, %o0
	cmp	%o0, 0
	bne	%icc, .LL473
	nop
	ldx	[%fp+1991], %o0
	ldx	[%fp+2175], %o1
	call	_ZNSt13_Format_cacheIcE11_M_populateERSt8ios_base, 0
	 nop
.LLEHE66:
.LL473:
	ldx	[%fp+1991], %i0
	return	%i7+8
	nop
.LLFE105:
.LLfe105:
	.size	_ZNSt13_Format_cacheIcE6_S_getERSt8ios_base,.LLfe105-_ZNSt13_Format_cacheIcE6_S_getERSt8ios_base
.section	".gcc_except_table",#alloc,#write
.LLLSDA105:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x41
	.uaword	.LLEHB62-.LLFB105
	.uaword	.LLEHE62-.LLEHB62
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB63-.LLFB105
	.uaword	.LLEHE63-.LLEHB63
	.uaword	.LL476-.LLFB105
	.byte	0x0
	.uaword	.LLEHB64-.LLFB105
	.uaword	.LLEHE64-.LLEHB64
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB65-.LLFB105
	.uaword	.LLEHE65-.LLEHB65
	.uaword	.LL475-.LLFB105
	.byte	0x0
	.uaword	.LLEHB66-.LLFB105
	.uaword	.LLEHE66-.LLEHB66
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZNSt13_Format_cacheIcE6_S_getERSt8ios_base",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv
	.type	_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv,#function
	.proc	012
_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv:
.LLFB106:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI105:
	!#PROLOGUE# 1
	ld	[%i0+232], %i0
	srl	%i0, 0, %i0
	return	%i7+8
	nop
.LLFE106:
.LLfe106:
	.size	_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv,.LLfe106-_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv
	.section	".rodata"
	.align 8
.LLC2:
	.asciz	"basic_ios::clear(iostate) caused exception"
.section	".gnu.linkonce.t._ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate",#alloc,#execinstr
	.align 4
	.weak	_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate
	.type	_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate,#function
	.proc	020
_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate:
.LLFB107:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI106:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %o0
	st	%o0, [%fp+2027]
	ldx	[%fp+2175], %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE5rdbufEv, 0
	 nop
	brz	%o0, .LL480
	nop
	ld	[%fp+2027], %o1
	ldx	[%fp+2175], %o0
	st	%o1, [%o0+232]
	ba,pt	%xcc, .LL481
	 nop
.LL480:
	lduw	[%fp+2027], %o0
	mov	1, %o1
	call	_ZStorSt12_Ios_IostateS_, 0
	 nop
	ldx	[%fp+2175], %o1
	st	%o0, [%o1+232]
.LL481:
	ldx	[%fp+2175], %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE7rdstateEv, 0
	 nop
	mov	%o0, %l0
	ldx	[%fp+2175], %o0
	call	_ZNKSt9basic_iosIcSt11char_traitsIcEE10exceptionsEv, 0
	 nop
	mov	%o0, %o1
	mov	%l0, %o0
	call	_ZStanSt12_Ios_IostateS_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL483
	nop
	sethi	%hh(.LLC2), %o0
	or	%o0, %hm(.LLC2), %o0
	sllx	%o0, 32, %o0
	sethi	%lm(.LLC2), %o1
	add	%o0, %o1, %o0
	or	%o0, %lo(.LLC2), %o0
	call	_ZSt19__throw_ios_failurePKc, 0
	 nop
.LL483:
	return	%i7+8
	nop
.LLFE107:
.LLfe107:
	.size	_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate,.LLfe107-_ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate
	.common	_ZNSs20_S_empty_rep_storageE,32,8
.section	".gnu.linkonce.t._ZNSs4_Rep10_M_refdataEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSs4_Rep10_M_refdataEv
	.type	_ZNSs4_Rep10_M_refdataEv,#function
	.proc	0102
_ZNSs4_Rep10_M_refdataEv:
.LLFB108:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI107:
	!#PROLOGUE# 1
	add	%i0, 24, %i0
	return	%i7+8
	nop
.LLFE108:
.LLfe108:
	.size	_ZNSs4_Rep10_M_refdataEv,.LLfe108-_ZNSs4_Rep10_M_refdataEv
.section	".gnu.linkonce.t._ZNSaIcEC2ERKS_",#alloc,#execinstr
	.align 4
	.weak	_ZNSaIcEC2ERKS_
	.type	_ZNSaIcEC2ERKS_,#function
	.proc	020
_ZNSaIcEC2ERKS_:
.LLFB109:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI108:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE109:
.LLfe109:
	.size	_ZNSaIcEC2ERKS_,.LLfe109-_ZNSaIcEC2ERKS_
.section	".gnu.linkonce.t._ZNSaIcEC1ERKS_",#alloc,#execinstr
	.align 4
	.weak	_ZNSaIcEC1ERKS_
	.type	_ZNSaIcEC1ERKS_,#function
	.proc	020
_ZNSaIcEC1ERKS_:
.LLFB110:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI109:
	!#PROLOGUE# 1
	return	%i7+8
	nop
.LLFE110:
.LLfe110:
	.size	_ZNSaIcEC1ERKS_,.LLfe110-_ZNSaIcEC1ERKS_
.section	".gnu.linkonce.t._ZNSs4_Rep10_M_destroyERKSaIcE",#alloc,#execinstr
	.align 4
	.weak	_ZNSs4_Rep10_M_destroyERKSaIcE
	.type	_ZNSs4_Rep10_M_destroyERKSaIcE,#function
	.proc	020
_ZNSs4_Rep10_M_destroyERKSaIcE:
.LLFB111:
	!#PROLOGUE# 0
	save	%sp, -240, %sp
.LLCFI110:
	!#PROLOGUE# 1
	mov	%i0, %l0
	stx	%i1, [%fp+2183]
	ldx	[%l0+8], %o0
	add	%o0, 25, %o0
	stx	%o0, [%fp+2023]
	add	%fp, 1999, %o0
	ldx	[%fp+2183], %o1
	call	_ZNSaIcEC1ERKS_, 0
	 nop
	add	%fp, 1999, %o0
	mov	%l0, %o1
	ldx	[%fp+2023], %o2
.LLEHB67:
	call	_ZNSaIcE10deallocateEPcm, 0
	 nop
.LLEHE67:
	add	%fp, 1999, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	ba,pt	%xcc, .LL501
	 nop
.LL503:
	stx	%i0, [%fp+1991]
	stx	%i1, [%fp+1983]
	ldx	[%fp+1991], %l0
	ldx	[%fp+1983], %l1
	add	%fp, 1999, %o0
	call	_ZNSaIcED1Ev, 0
	 nop
	stx	%l0, [%fp+1991]
	stx	%l1, [%fp+1983]
.LL504:
	ldx	[%fp+1983], %o0
	cmp	%o0, -1
	be	%xcc, .LL499
	nop
	ldx	[%fp+1991], %o0
.LLEHB68:
	call	_Unwind_Resume, 0
	 nop
.LL499:
	ldx	[%fp+1991], %o0
	call	__cxa_call_unexpected, 0
	 nop
.LLEHE68:
.LL501:
	return	%i7+8
	nop
.LLFE111:
.LLfe111:
	.size	_ZNSs4_Rep10_M_destroyERKSaIcE,.LLfe111-_ZNSs4_Rep10_M_destroyERKSaIcE
.section	".gcc_except_table",#alloc,#write
	.align 8
.LLLSDA111:
	.byte	0xff
	.byte	0x0
	.byte	0x25
	.byte	0x3
	.byte	0x1a
	.uaword	.LLEHB67-.LLFB111
	.uaword	.LLEHE67-.LLEHB67
	.uaword	.LL503-.LLFB111
	.byte	0x3
	.uaword	.LLEHB68-.LLFB111
	.uaword	.LLEHE68-.LLEHB68
	.uaword	0x0
	.byte	0x0
	.byte	0x7f
	.byte	0x0
	.byte	0x0
	.byte	0x7d
	.align 8
	.byte	0x0
.section	".gnu.linkonce.t._ZNSs4_Rep10_M_destroyERKSaIcE",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EEC2ERKS3_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EEC2ERKS3_
	.type	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EEC2ERKS3_,#function
	.proc	020
_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EEC2ERKS3_:
.LLFB112:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI111:
	!#PROLOGUE# 1
	mov	%i0, %l0
	mov	%i1, %o1
	mov	%l0, %o0
	call	_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EEC2ERKS3_, 0
	 nop
	mov	%l0, %o0
	call	_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_get_nodeEv, 0
	 nop
	stx	%o0, [%l0]
	return	%i7+8
	nop
.LLFE112:
.LLfe112:
	.size	_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EEC2ERKS3_,.LLfe112-_ZNSt13_Rb_tree_baseISt4pairIKSsiESaIS2_EEC2ERKS3_
.section	".gnu.linkonce.t._ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE19_M_empty_initializeEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE19_M_empty_initializeEv
	.type	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE19_M_empty_initializeEv,#function
	.proc	020
_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE19_M_empty_initializeEv:
.LLFB113:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI112:
	!#PROLOGUE# 1
	mov	%i0, %l0
	ldx	[%l0], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8_S_colorEPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	stb	%g0, [%o0]
	mov	%l0, %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv, 0
	 nop
	stx	%g0, [%o0]
	mov	%l0, %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv, 0
	 nop
	mov	%o0, %o1
	ldx	[%l0], %o0
	stx	%o0, [%o1]
	mov	%l0, %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv, 0
	 nop
	mov	%o0, %o1
	ldx	[%l0], %o0
	stx	%o0, [%o1]
	return	%i7+8
	nop
.LLFE113:
.LLfe113:
	.size	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE19_M_empty_initializeEv,.LLfe113-_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE19_M_empty_initializeEv
.section	".gnu.linkonce.t._ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv
	.type	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv,#function
	.proc	0510
_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv:
.LLFB114:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI113:
	!#PROLOGUE# 1
	ldx	[%i0], %i0
	add	%i0, 8, %i0
	return	%i7+8
	nop
.LLFE114:
.LLfe114:
	.size	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv,.LLfe114-_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv
.section	".gnu.linkonce.t._ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv
	.type	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv,#function
	.proc	0510
_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv:
.LLFB115:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI114:
	!#PROLOGUE# 1
	ldx	[%i0], %i0
	add	%i0, 16, %i0
	return	%i7+8
	nop
.LLFE115:
.LLfe115:
	.size	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv,.LLfe115-_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11_M_leftmostEv
.section	".gnu.linkonce.t._ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv
	.type	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv,#function
	.proc	0510
_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv:
.LLFB116:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI115:
	!#PROLOGUE# 1
	ldx	[%i0], %i0
	add	%i0, 24, %i0
	return	%i7+8
	nop
.LLFE116:
.LLfe116:
	.size	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv,.LLfe116-_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv
.section	".gnu.linkonce.t._ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E",#alloc,#execinstr
	.align 4
	.weak	_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E
	.type	_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E,#function
	.proc	020
_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E:
.LLFB117:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI116:
	!#PROLOGUE# 1
	mov	%i1, %o0
	mov	1, %o1
	call	_ZNSt12simple_allocISt13_Rb_tree_nodeISt4pairIKSsiEESt24__default_alloc_templateILb1ELi0EEE10deallocateEPS4_m, 0
	 nop
	return	%i7+8
	nop
.LLFE117:
.LLfe117:
	.size	_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E,.LLfe117-_ZNSt19_Rb_tree_alloc_baseISt4pairIKSsiESaIS2_ELb1EE11_M_put_nodeEPSt13_Rb_tree_nodeIS2_E
.section	".gnu.linkonce.t._ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv
	.type	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv,#function
	.proc	04
_ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv:
.LLFB118:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI117:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	ldx	[%fp+2175], %o1
	ldx	[%o1+40], %o0
	brz	%o0, .LL517
	nop
	ldx	[%fp+2175], %o2
	ldx	[%o2+40], %o1
	ldx	[%fp+2175], %o2
	ldx	[%o2+48], %o0
	cmp	%o1, %o0
	bgeu	%xcc, .LL517
	nop
	ldx	[%fp+2175], %o0
	call	_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv, 0
	 nop
	call	_ZNSt11char_traitsIcE11to_int_typeERKc, 0
	 nop
	st	%o0, [%fp+2027]
	ba,pt	%xcc, .LL518
	 nop
.LL517:
	ldx	[%fp+2175], %o1
	ldx	[%o1], %o0
	add	%o0, 72, %o0
	ldx	[%o0], %o1
	ldx	[%fp+2175], %o0
	call	%o1, 0
	 nop
	st	%o0, [%fp+2027]
.LL518:
	ldsw	[%fp+2027], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE118:
.LLfe118:
	.size	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv,.LLfe118-_ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv
.section	".gnu.linkonce.t._ZNSt15basic_streambufIcSt11char_traitsIcEE6snextcEv",#alloc,#execinstr
	.align 4
	.weak	_ZNSt15basic_streambufIcSt11char_traitsIcEE6snextcEv
	.type	_ZNSt15basic_streambufIcSt11char_traitsIcEE6snextcEv,#function
	.proc	04
_ZNSt15basic_streambufIcSt11char_traitsIcEE6snextcEv:
.LLFB119:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI118:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	call	_ZNSt11char_traitsIcE3eofEv, 0
	 nop
	st	%o0, [%fp+2027]
	ldx	[%fp+2175], %o0
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv, 0
	 nop
	mov	%o0, %o1
	ld	[%fp+2027], %o0
	cmp	%o1, %o0
	be	%icc, .LL521
	nop
	ldx	[%fp+2175], %o0
	call	_ZNSt15basic_streambufIcSt11char_traitsIcEE5sgetcEv, 0
	 nop
	st	%o0, [%fp+2023]
	ba,pt	%xcc, .LL522
	 nop
.LL521:
	ld	[%fp+2027], %o0
	st	%o0, [%fp+2023]
.LL522:
	ldsw	[%fp+2023], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE119:
.LLfe119:
	.size	_ZNSt15basic_streambufIcSt11char_traitsIcEE6snextcEv,.LLfe119-_ZNSt15basic_streambufIcSt11char_traitsIcEE6snextcEv
	.section	".rodata"
	.align 8
.LLC3:
	.asciz	"basic_string::_M_check"
.section	".gnu.linkonce.t._ZNKSs8_M_checkEm",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs8_M_checkEm
	.type	_ZNKSs8_M_checkEm,#function
	.proc	010
_ZNKSs8_M_checkEm:
.LLFB120:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI119:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2175], %o0
	call	_ZNKSs4sizeEv, 0
	 nop
	ldx	[%fp+2183], %o1
	cmp	%o1, %o0
	bleu	%xcc, .LL525
	nop
	sethi	%hh(.LLC3), %o0
	or	%o0, %hm(.LLC3), %o0
	sllx	%o0, 32, %o0
	sethi	%lm(.LLC3), %o1
	add	%o0, %o1, %o0
	or	%o0, %lo(.LLC3), %o0
	call	_ZSt20__throw_out_of_rangePKc, 0
	 nop
.LL525:
	ldx	[%fp+2175], %o0
	call	_ZNKSs9_M_ibeginEv, 0
	 nop
	stx	%o0, [%fp+2015]
	ldx	[%fp+2183], %o0
	stx	%o0, [%fp+2007]
	add	%fp, 2015, %o0
	add	%fp, 2007, %o1
	call	_ZNKSt17__normal_iteratorIPcSsEplERKl, 0
	 nop
	stx	%o0, [%fp+2023]
	ldx	[%fp+2023], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE120:
.LLfe120:
	.size	_ZNKSs8_M_checkEm,.LLfe120-_ZNKSs8_M_checkEm
.section	".gnu.linkonce.t._ZNKSs7_M_foldEmm",#alloc,#execinstr
	.align 4
	.weak	_ZNKSs7_M_foldEmm
	.type	_ZNKSs7_M_foldEmm,#function
	.proc	010
_ZNKSs7_M_foldEmm:
.LLFB121:
	!#PROLOGUE# 0
	save	%sp, -256, %sp
.LLCFI120:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	ldx	[%fp+2175], %o0
	call	_ZNKSs4sizeEv, 0
	 nop
	ldx	[%fp+2183], %o1
	sub	%o0, %o1, %o0
	ldx	[%fp+2191], %o1
	cmp	%o1, %o0
	mov	0, %o0
	movlu	%xcc, 1, %o0
	stb	%o0, [%fp+2030]
	ldub	[%fp+2030], %o0
	cmp	%o0, 0
	be	%icc, .LL528
	nop
	ldx	[%fp+2191], %o0
	stx	%o0, [%fp+1967]
	ba,pt	%xcc, .LL529
	 nop
.LL528:
	ldx	[%fp+2175], %o0
	call	_ZNKSs4sizeEv, 0
	 nop
	stx	%o0, [%fp+1967]
	ldx	[%fp+1967], %o1
	ldx	[%fp+2183], %o0
	sub	%o1, %o0, %o1
	stx	%o1, [%fp+1967]
.LL529:
	ldx	[%fp+1967], %o1
	stx	%o1, [%fp+2015]
	ldx	[%fp+2175], %o0
	call	_ZNKSs9_M_ibeginEv, 0
	 nop
	stx	%o0, [%fp+1991]
	ldx	[%fp+2183], %o0
	stx	%o0, [%fp+1983]
	add	%fp, 1991, %o0
	add	%fp, 1983, %o1
	call	_ZNKSt17__normal_iteratorIPcSsEplERKl, 0
	 nop
	stx	%o0, [%fp+1999]
	ldx	[%fp+2015], %o0
	stx	%o0, [%fp+1975]
	add	%fp, 1999, %o0
	add	%fp, 1975, %o1
	call	_ZNKSt17__normal_iteratorIPcSsEplERKl, 0
	 nop
	stx	%o0, [%fp+2007]
	ldx	[%fp+2007], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE121:
.LLfe121:
	.size	_ZNKSs7_M_foldEmm,.LLfe121-_ZNKSs7_M_foldEmm
.section	".gnu.linkonce.t._ZNSs7replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_",#alloc,#execinstr
	.align 4
	.weak	_ZNSs7replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_
	.type	_ZNSs7replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_,#function
	.proc	0110
_ZNSs7replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_:
.LLFB122:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI121:
	!#PROLOGUE# 1
	mov	%i0, %o0
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	mov	%i3, %o3
	mov	%i4, %o4
	stb	%g0, [%fp+2030]
	ldx	[%fp+2183], %o1
	ldx	[%fp+2191], %o2
	mov	0, %o5
	call	_ZNSs10_M_replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_St20forward_iterator_tag, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE122:
.LLfe122:
	.size	_ZNSs7replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_,.LLfe122-_ZNSs7replaceIPcEERSsSt17__normal_iteratorIS0_SsES3_T_S4_
	.weak	_ZNSs4_Rep11_S_max_sizeE
.section	".gnu.linkonce.r._ZNSs4_Rep11_S_max_sizeE",#alloc
	.align 8
	.type	_ZNSs4_Rep11_S_max_sizeE,#object
	.size	_ZNSs4_Rep11_S_max_sizeE,8
_ZNSs4_Rep11_S_max_sizeE:
	.uaword	1073741823
	.uaword	-7
.section	".gnu.linkonce.t._ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv
	.type	_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv,#function
	.proc	0102
_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv:
.LLFB123:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI122:
	!#PROLOGUE# 1
	ldx	[%i0+40], %i0
	return	%i7+8
	nop
.LLFE123:
.LLfe123:
	.size	_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv,.LLfe123-_ZNKSt15basic_streambufIcSt11char_traitsIcEE4gptrEv
.section	".gnu.linkonce.t._ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl",#alloc,#execinstr
	.align 4
	.weak	_ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl
	.type	_ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl,#function
	.proc	020
_ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl:
.LLFB124:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI123:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2175], %o0
	ldx	[%o0+64], %i0
	xor	%i0, 0, %i0
	mov	0, %o0
	movrne	%i0, 1, %o0
	mov	%o0, %i0
	stb	%i0, [%fp+2030]
	ldx	[%fp+2175], %o0
	ldx	[%o0+40], %i0
	ldx	[%fp+2183], %o0
	add	%i0, %o0, %i0
	ldx	[%fp+2175], %o0
	stx	%i0, [%o0+40]
	ldub	[%fp+2030], %i0
	cmp	%i0, 0
	be	%icc, .LL537
	nop
	ldx	[%fp+2175], %o0
	ldub	[%o0+24], %i0
	and	%i0, 0xff, %i0
	cmp	%i0, 0
	be	%icc, .LL537
	nop
	ldx	[%fp+2175], %o0
	ldx	[%o0+64], %i0
	ldx	[%fp+2183], %o0
	add	%i0, %o0, %i0
	ldx	[%fp+2175], %o0
	stx	%i0, [%o0+64]
.LL537:
	return	%i7+8
	nop
.LLFE124:
.LLfe124:
	.size	_ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl,.LLfe124-_ZNSt15basic_streambufIcSt11char_traitsIcEE14_M_in_cur_moveEl
.section	".gnu.linkonce.t._ZNSs6appendEmc",#alloc,#execinstr
	.align 4
	.weak	_ZNSs6appendEmc
	.type	_ZNSs6appendEmc,#function
	.proc	0110
_ZNSs6appendEmc:
.LLFB125:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI124:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	mov	%i2, %o0
	stb	%o0, [%fp+2191]
	ldx	[%fp+2175], %o0
	call	_ZNKSs4sizeEv, 0
	 nop
	mov	%o0, %o1
	ldx	[%fp+2183], %o0
	add	%o0, %o1, %o0
	stx	%o0, [%fp+2023]
	ldx	[%fp+2175], %o0
	call	_ZNKSs8capacityEv, 0
	 nop
	mov	%o0, %o1
	ldx	[%fp+2023], %o0
	cmp	%o0, %o1
	bleu	%xcc, .LL539
	nop
	ldx	[%fp+2175], %o0
	ldx	[%fp+2023], %o1
	call	_ZNSs7reserveEm, 0
	 nop
.LL539:
	ldx	[%fp+2175], %o0
	call	_ZNKSs7_M_iendEv, 0
	 nop
	stx	%o0, [%fp+2015]
	ldx	[%fp+2175], %o0
	call	_ZNKSs7_M_iendEv, 0
	 nop
	stx	%o0, [%fp+2007]
	ldub	[%fp+2191], %o0
	sllx	%o0, 56, %o0
	srax	%o0, 56, %o4
	ldx	[%fp+2175], %o0
	ldx	[%fp+2015], %o1
	ldx	[%fp+2007], %o2
	ldx	[%fp+2183], %o3
	call	_ZNSs7replaceESt17__normal_iteratorIPcSsES1_mc, 0
	 nop
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE125:
.LLfe125:
	.size	_ZNSs6appendEmc,.LLfe125-_ZNSs6appendEmc
.section	".gnu.linkonce.t._ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11lower_boundERS1_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11lower_boundERS1_
	.type	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11lower_boundERS1_,#function
	.proc	010
_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11lower_boundERS1_:
.LLFB126:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI125:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	ldx	[%fp+2183], %o1
	ldx	[%o1], %o0
	stx	%o0, [%fp+2023]
	ldx	[%fp+2183], %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_M_rootEv, 0
	 nop
	ldx	[%o0], %o0
	stx	%o0, [%fp+2015]
.LL542:
	ldx	[%fp+2015], %o0
	brnz	%o0, .LL544
	nop
	ba,pt	%xcc, .LL543
	 nop
.LL544:
	ldx	[%fp+2015], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE6_S_keyEPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	mov	%o0, %o1
	ldx	[%fp+2183], %o2
	add	%o2, 16, %o0
	ldx	[%fp+2191], %o2
	call	_ZNKSt4lessISsEclERKSsS2_, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL545
	nop
	ldx	[%fp+2015], %o0
	stx	%o0, [%fp+2023]
	ldx	[%fp+2015], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE7_S_leftEPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	ldx	[%o0], %o0
	stx	%o0, [%fp+2015]
	ba,pt	%xcc, .LL542
	 nop
.LL545:
	ldx	[%fp+2015], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8_S_rightEPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	ldx	[%o0], %o0
	stx	%o0, [%fp+2015]
	ba,pt	%xcc, .LL542
	 nop
.LL543:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2023], %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	ldx	[%fp+2175], %i0
	return	%i7+8
	nop
.LLFE126:
.LLfe126:
	.size	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11lower_boundERS1_,.LLfe126-_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE11lower_boundERS1_
.section	".gnu.linkonce.t._ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8key_compEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8key_compEv
	.type	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8key_compEv,#function
	.proc	010
_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8key_compEv:
.LLFB127:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI126:
	!#PROLOGUE# 1
	ldub	[%i0+16], %i0
	and	%i0, 0xff, %i0
	sllx	%i0, 56, %i0
	return	%i7+8
	nop
.LLFE127:
.LLfe127:
	.size	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8key_compEv,.LLfe127-_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8key_compEv
.section	".gnu.linkonce.t._ZStltIcSt11char_traitsIcESaIcEEbRKSbIT_T0_T1_ES8_",#alloc,#execinstr
	.align 4
	.weak	_ZStltIcSt11char_traitsIcESaIcEEbRKSbIT_T0_T1_ES8_
	.type	_ZStltIcSt11char_traitsIcESaIcEEbRKSbIT_T0_T1_ES8_,#function
	.proc	00
_ZStltIcSt11char_traitsIcESaIcEEbRKSbIT_T0_T1_ES8_:
.LLFB128:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI127:
	!#PROLOGUE# 1
	mov	%i0, %o0
	mov	%i1, %o1
	call	_ZNKSs7compareERKSs, 0
	 nop
	srl	%o0, 31, %o0
	and	%o0, 0xff, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE128:
.LLfe128:
	.size	_ZStltIcSt11char_traitsIcESaIcEEbRKSbIT_T0_T1_ES8_,.LLfe128-_ZStltIcSt11char_traitsIcESaIcEEbRKSbIT_T0_T1_ES8_
.section	".gnu.linkonce.t._ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueESt17_Rb_tree_iteratorIS2_RS2_PS2_ERKS2_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueESt17_Rb_tree_iteratorIS2_RS2_PS2_ERKS2_
	.type	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueESt17_Rb_tree_iteratorIS2_RS2_PS2_ERKS2_,#function
	.proc	010
_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueESt17_Rb_tree_iteratorIS2_RS2_PS2_ERKS2_:
.LLFB129:
	!#PROLOGUE# 0
	save	%sp, -272, %sp
.LLCFI128:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	stx	%i3, [%fp+2199]
	ldx	[%fp+2183], %o1
	ldx	[%o1], %o0
	ldx	[%fp+2191], %o2
	ldx	[%o2], %o1
	ldx	[%o0+16], %o0
	cmp	%o1, %o0
	bne	%xcc, .LL553
	nop
	ldx	[%fp+2183], %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE4sizeEv, 0
	 nop
	brz	%o0, .LL554
	nop
	ldx	[%fp+2191], %o3
	ldx	[%o3], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE6_S_keyEPSt18_Rb_tree_node_base, 0
	 nop
	mov	%o0, %l0
	stb	%g0, [%fp+2030]
	add	%fp, 2030, %o0
	ldx	[%fp+2199], %o1
	call	_ZNKSt10_Select1stISt4pairIKSsiEEclERKS2_, 0
	 nop
	mov	%o0, %o2
	ldx	[%fp+2183], %o4
	add	%o4, 16, %o0
	mov	%l0, %o1
	call	_ZNKSt4lessISsEclERKSsS2_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL554
	nop
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2191], %o3
	ldx	[%o3], %o2
	ldx	[%fp+2191], %o4
	ldx	[%o4], %o3
	ldx	[%fp+2199], %o4
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE9_M_insertEPSt18_Rb_tree_node_baseSA_RKS2_, 0
	 nop
	ba,pt	%xcc, .LL552
	 nop
.LL554:
	add	%fp, 1999, %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2199], %o2
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueERKS2_, 0
	 nop
	ldx	[%fp+2175], %o0
	add	%fp, 1999, %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_, 0
	 nop
	ba,pt	%xcc, .LL552
	 nop
.LL553:
	ldx	[%fp+2191], %o0
	ldx	[%o0], %o1
	ldx	[%fp+2183], %o2
	ldx	[%o2], %o0
	cmp	%o1, %o0
	bne	%xcc, .LL557
	nop
	ldx	[%fp+2183], %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv, 0
	 nop
	ldx	[%o0], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE6_S_keyEPSt13_Rb_tree_nodeIS2_E, 0
	 nop
	mov	%o0, %l0
	stb	%g0, [%fp+1998]
	add	%fp, 1998, %o0
	ldx	[%fp+2199], %o1
	call	_ZNKSt10_Select1stISt4pairIKSsiEEclERKS2_, 0
	 nop
	mov	%o0, %o2
	ldx	[%fp+2183], %o3
	add	%o3, 16, %o0
	mov	%l0, %o1
	call	_ZNKSt4lessISsEclERKSsS2_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL558
	nop
	ldx	[%fp+2183], %o0
	call	_ZNKSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE12_M_rightmostEv, 0
	 nop
	mov	%o0, %o3
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	mov	0, %o2
	ldx	[%o3], %o3
	ldx	[%fp+2199], %o4
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE9_M_insertEPSt18_Rb_tree_node_baseSA_RKS2_, 0
	 nop
	ba,pt	%xcc, .LL552
	 nop
.LL558:
	add	%fp, 1999, %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2199], %o2
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueERKS2_, 0
	 nop
	ldx	[%fp+2175], %o0
	add	%fp, 1999, %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_, 0
	 nop
	ba,pt	%xcc, .LL552
	 nop
.LL557:
	add	%fp, 1999, %o0
	ldx	[%fp+2191], %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_, 0
	 nop
	add	%fp, 1999, %o0
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EmmEv, 0
	 nop
	stb	%g0, [%fp+1966]
	ldx	[%fp+1999], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE6_S_keyEPSt18_Rb_tree_node_base, 0
	 nop
	mov	%o0, %l0
	stb	%g0, [%fp+1997]
	add	%fp, 1997, %o0
	ldx	[%fp+2199], %o1
	call	_ZNKSt10_Select1stISt4pairIKSsiEEclERKS2_, 0
	 nop
	mov	%o0, %o2
	ldx	[%fp+2183], %o4
	add	%o4, 16, %o0
	mov	%l0, %o1
	call	_ZNKSt4lessISsEclERKSsS2_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL562
	nop
	stb	%g0, [%fp+1996]
	add	%fp, 1996, %o0
	ldx	[%fp+2199], %o1
	call	_ZNKSt10_Select1stISt4pairIKSsiEEclERKS2_, 0
	 nop
	mov	%o0, %l0
	ldx	[%fp+2191], %o1
	ldx	[%o1], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE6_S_keyEPSt18_Rb_tree_node_base, 0
	 nop
	mov	%o0, %o2
	ldx	[%fp+2183], %o3
	add	%o3, 16, %o0
	mov	%l0, %o1
	call	_ZNKSt4lessISsEclERKSsS2_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL562
	nop
	mov	1, %o4
	stb	%o4, [%fp+1966]
.LL562:
	ldub	[%fp+1966], %o0
	cmp	%o0, 0
	be	%icc, .LL561
	nop
	ldx	[%fp+1999], %o0
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE8_S_rightEPSt18_Rb_tree_node_base, 0
	 nop
	ldx	[%o0], %o0
	brnz	%o0, .LL563
	nop
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	mov	0, %o2
	ldx	[%fp+1999], %o3
	ldx	[%fp+2199], %o4
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE9_M_insertEPSt18_Rb_tree_node_baseSA_RKS2_, 0
	 nop
	ba,pt	%xcc, .LL552
	 nop
.LL563:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2191], %o3
	ldx	[%o3], %o2
	ldx	[%fp+2191], %o4
	ldx	[%o4], %o3
	ldx	[%fp+2199], %o4
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE9_M_insertEPSt18_Rb_tree_node_baseSA_RKS2_, 0
	 nop
	ba,pt	%xcc, .LL552
	 nop
.LL561:
	add	%fp, 1967, %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2199], %o2
	call	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueERKS2_, 0
	 nop
	ldx	[%fp+2175], %o0
	add	%fp, 1967, %o1
	call	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1ERKS5_, 0
	 nop
.LL552:
	ldx	[%fp+2175], %i0
	return	%i7+8
	nop
.LLFE129:
.LLfe129:
	.size	_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueESt17_Rb_tree_iteratorIS2_RS2_PS2_ERKS2_,.LLfe129-_ZNSt8_Rb_treeISsSt4pairIKSsiESt10_Select1stIS2_ESt4lessISsESaIS2_EE13insert_uniqueESt17_Rb_tree_iteratorIS2_RS2_PS2_ERKS2_
.section	".gnu.linkonce.t._ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EEC2ERKS2_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EEC2ERKS2_
	.type	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EEC2ERKS2_,#function
	.proc	020
_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EEC2ERKS2_:
.LLFB130:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI129:
	!#PROLOGUE# 1
	stx	%g0, [%i0]
	stx	%g0, [%i0+8]
	stx	%g0, [%i0+16]
	return	%i7+8
	nop
.LLFE130:
.LLfe130:
	.size	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EEC2ERKS2_,.LLfe130-_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EEC2ERKS2_
.section	".gnu.linkonce.t._ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EE13_M_deallocateEPS1_m",#alloc,#execinstr
	.align 4
	.weak	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EE13_M_deallocateEPS1_m
	.type	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EE13_M_deallocateEPS1_m,#function
	.proc	020
_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EE13_M_deallocateEPS1_m:
.LLFB131:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI130:
	!#PROLOGUE# 1
	mov	%i1, %o0
	mov	%i2, %o1
	call	_ZNSt12simple_allocISt4pairIiSsESt24__default_alloc_templateILb1ELi0EEE10deallocateEPS1_m, 0
	 nop
	return	%i7+8
	nop
.LLFE131:
.LLfe131:
	.size	_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EE13_M_deallocateEPS1_m,.LLfe131-_ZNSt18_Vector_alloc_baseISt4pairIiSsESaIS1_ELb1EE13_M_deallocateEPS1_m
.section	".gnu.linkonce.t._ZSt8_DestroyIPSt4pairIiSsEEvT_S3_",#alloc,#execinstr
	.align 4
	.weak	_ZSt8_DestroyIPSt4pairIiSsEEvT_S3_
	.type	_ZSt8_DestroyIPSt4pairIiSsEEvT_S3_,#function
	.proc	020
_ZSt8_DestroyIPSt4pairIiSsEEvT_S3_:
.LLFB132:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI131:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %l0
	add	%fp, 2175, %o0
	call	_ZSt12__value_typeIPSt4pairIiSsEEPNSt15iterator_traitsIT_E10value_typeERKS4_, 0
	 nop
	mov	%o0, %o2
	ldx	[%fp+2175], %o0
	mov	%l0, %o1
	call	_ZSt9__destroyIPSt4pairIiSsES1_EvT_S3_PT0_, 0
	 nop
	return	%i7+8
	nop
.LLFE132:
.LLfe132:
	.size	_ZSt8_DestroyIPSt4pairIiSsEEvT_S3_,.LLfe132-_ZSt8_DestroyIPSt4pairIiSsEEvT_S3_
.section	".gnu.linkonce.t._ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E",#alloc,#execinstr
	.align 4
	.weak	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E
	.type	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E,#function
	.proc	020
_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E:
.LLFB133:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI132:
	!#PROLOGUE# 1
	mov	%i0, %i2
	mov	%i1, %i0
	stx	%i0, [%i2]
	return	%i7+8
	nop
.LLFE133:
.LLfe133:
	.size	_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E,.LLfe133-_ZNSt17_Rb_tree_iteratorISt4pairIKSsiERS2_PS2_EC1EPSt13_Rb_tree_nodeIS2_E
.section	".gnu.linkonce.t._ZNSs4_Rep7_M_grabERKSaIcES2_",#alloc,#execinstr
	.align 4
	.weak	_ZNSs4_Rep7_M_grabERKSaIcES2_
	.type	_ZNSs4_Rep7_M_grabERKSaIcES2_,#function
	.proc	0102
_ZNSs4_Rep7_M_grabERKSaIcES2_:
.LLFB134:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI133:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	ldx	[%fp+2175], %o0
	call	_ZNKSs4_Rep12_M_is_leakedEv, 0
	 nop
	cmp	%o0, 0
	bne	%icc, .LL574
	nop
	ldx	[%fp+2183], %o0
	ldx	[%fp+2191], %o1
	call	_ZSteqIccEbRKSaIT_ERKSaIT0_E, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL574
	nop
	ldx	[%fp+2175], %o0
	call	_ZNSs4_Rep10_M_refcopyEv, 0
	 nop
	stx	%o0, [%fp+2023]
	ba,pt	%xcc, .LL575
	 nop
.LL574:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	mov	0, %o2
	call	_ZNSs4_Rep8_M_cloneERKSaIcEm, 0
	 nop
	stx	%o0, [%fp+2023]
.LL575:
	ldx	[%fp+2023], %i0
	return	%i7+8
	nop
.LLFE134:
.LLfe134:
	.size	_ZNSs4_Rep7_M_grabERKSaIcES2_,.LLfe134-_ZNSs4_Rep7_M_grabERKSaIcES2_
.section	".gnu.linkonce.t._ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_",#alloc,#execinstr
	.align 4
	.weak	_ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_
	.type	_ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_,#function
	.proc	010
_ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_:
.LLFB135:
	!#PROLOGUE# 0
	save	%sp, -224, %sp
.LLCFI134:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	mov	%i1, %o0
	stx	%i2, [%fp+2191]
	st	%o0, [%fp+2183]
	ldx	[%fp+2175], %o0
	add	%fp, 2183, %o1
	ldx	[%fp+2191], %o2
.LLEHB69:
	call	_ZNSt4pairIiSsEC1ERKiRKSs, 0
	 nop
.LLEHE69:
	ldx	[%fp+2191], %o0
.LLEHB70:
	call	_ZNSsD1Ev, 0
	 nop
.LLEHE70:
	ba,pt	%xcc, .LL578
	 nop
.LL584:
	stx	%i0, [%fp+2023]
	ldx	[%fp+2023], %l0
	ldx	[%fp+2191], %o0
	call	_ZNSsD1Ev, 0
	 nop
	stx	%l0, [%fp+2023]
	ldx	[%fp+2023], %o0
.LLEHB71:
	call	_Unwind_Resume, 0
	 nop
.LLEHE71:
.LL578:
	ldx	[%fp+2175], %i0
	return	%i7+8
	nop
.LLFE135:
.LLfe135:
	.size	_ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_,.LLfe135-_ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_
.section	".gcc_except_table",#alloc,#write
.LLLSDA135:
	.byte	0xff
	.byte	0xff
	.byte	0x3
	.byte	0x27
	.uaword	.LLEHB69-.LLFB135
	.uaword	.LLEHE69-.LLEHB69
	.uaword	.LL584-.LLFB135
	.byte	0x0
	.uaword	.LLEHB70-.LLFB135
	.uaword	.LLEHE70-.LLEHB70
	.uaword	0x0
	.byte	0x0
	.uaword	.LLEHB71-.LLFB135
	.uaword	.LLEHE71-.LLEHB71
	.uaword	0x0
	.byte	0x0
.section	".gnu.linkonce.t._ZSt9make_pairIiSsESt4pairIT_T0_ES1_S2_",#alloc,#execinstr
.section	".gnu.linkonce.t._ZNSt6vectorISt4pairIiSsESaIS1_EE9push_backERKS1_",#alloc,#execinstr
	.align 4
	.weak	_ZNSt6vectorISt4pairIiSsESaIS1_EE9push_backERKS1_
	.type	_ZNSt6vectorISt4pairIiSsESaIS1_EE9push_backERKS1_,#function
	.proc	020
_ZNSt6vectorISt4pairIiSsESaIS1_EE9push_backERKS1_:
.LLFB136:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI135:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	ldx	[%fp+2175], %o0
	ldx	[%o0+8], %o1
	ldx	[%fp+2175], %o2
	ldx	[%o2+16], %o0
	cmp	%o1, %o0
	be	%xcc, .LL586
	nop
	ldx	[%fp+2175], %o1
	ldx	[%o1+8], %o0
	ldx	[%fp+2183], %o1
	call	_ZSt9constructISt4pairIiSsES1_EvPT_RKT0_, 0
	 nop
	ldx	[%fp+2175], %o2
	ldx	[%o2+8], %o0
	add	%o0, 16, %o0
	ldx	[%fp+2175], %o1
	stx	%o0, [%o1+8]
	ba,pt	%xcc, .LL588
	 nop
.LL586:
	ldx	[%fp+2175], %o0
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EE3endEv, 0
	 nop
	stx	%o0, [%fp+2023]
	ldx	[%fp+2175], %o0
	ldx	[%fp+2023], %o1
	ldx	[%fp+2183], %o2
	call	_ZNSt6vectorISt4pairIiSsESaIS1_EE13_M_insert_auxESt17__normal_iteratorIPS1_S3_ERKS1_, 0
	 nop
.LL588:
	return	%i7+8
	nop
.LLFE136:
.LLfe136:
	.size	_ZNSt6vectorISt4pairIiSsESaIS1_EE9push_backERKS1_,.LLfe136-_ZNSt6vectorISt4pairIiSsESaIS1_EE9push_backERKS1_
.section	".gnu.linkonce.t._ZSteqIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E",#alloc,#execinstr
	.align 4
	.weak	_ZSteqIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E
	.type	_ZSteqIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E,#function
	.proc	00
_ZSteqIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E:
.LLFB137:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI136:
	!#PROLOGUE# 1
	mov	%i0, %o0
	mov	%i1, %l0
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEE4baseEv, 0
	 nop
	mov	%o0, %l1
	mov	%l0, %o0
	call	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEE4baseEv, 0
	 nop
	ldx	[%l1], %o1
	ldx	[%o0], %o0
	xor	%o1, %o0, %o0
	mov	0, %o1
	movre	%o0, 1, %o1
	mov	%o1, %o0
	and	%o0, 0xff, %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE137:
.LLfe137:
	.size	_ZSteqIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E,.LLfe137-_ZSteqIPSt4pairIiSsES2_St6vectorIS1_SaIS1_EEEbRKSt17__normal_iteratorIT_T1_ERKS6_IT0_S8_E
.section	".gnu.linkonce.t._ZSt12partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_S8_",#alloc,#execinstr
	.align 4
	.weak	_ZSt12partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_S8_
	.type	_ZSt12partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_S8_,#function
	.proc	020
_ZSt12partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_S8_:
.LLFB138:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI137:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	add	%fp, 2175, %o0
	call	_ZSt12__value_typeISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEPNSt15iterator_traitsIT_E10value_typeERKS9_, 0
	 nop
	mov	%o0, %o3
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	ldx	[%fp+2191], %o2
	call	_ZSt14__partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEES2_EvT_S8_S8_PT0_, 0
	 nop
	return	%i7+8
	nop
.LLFE138:
.LLfe138:
	.size	_ZSt12partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_S8_,.LLfe138-_ZSt12partial_sortISt17__normal_iteratorIPSt4pairIiSsESt6vectorIS2_SaIS2_EEEEvT_S8_S8_
.section	".gnu.linkonce.t._ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv
	.type	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv,#function
	.proc	0110
_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv:
.LLFB139:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI138:
	!#PROLOGUE# 1
	ldx	[%i0], %i0
	return	%i7+8
	nop
.LLFE139:
.LLfe139:
	.size	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv,.LLfe139-_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEdeEv
.section	".gnu.linkonce.t._ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl
	.type	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl,#function
	.proc	010
_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl:
.LLFB140:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI139:
	!#PROLOGUE# 1
	mov	%i0, %o2
	mov	%i1, %o0
	ldx	[%o0], %o0
	sllx	%o0, 4, %o1
	ldx	[%o2], %o0
	add	%o0, %o1, %o0
	stx	%o0, [%fp+2015]
	add	%fp, 2023, %o0
	add	%fp, 2015, %o1
	call	_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_, 0
	 nop
	ldx	[%fp+2023], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE140:
.LLfe140:
	.size	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl,.LLfe140-_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEplERKl
.section	".gnu.linkonce.t._ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKl",#alloc,#execinstr
	.align 4
	.weak	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKl
	.type	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKl,#function
	.proc	010
_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKl:
.LLFB141:
	!#PROLOGUE# 0
	save	%sp, -208, %sp
.LLCFI140:
	!#PROLOGUE# 1
	mov	%i0, %o2
	mov	%i1, %o0
	ldx	[%o0], %o0
	sllx	%o0, 4, %o1
	ldx	[%o2], %o0
	sub	%o0, %o1, %o0
	stx	%o0, [%fp+2015]
	add	%fp, 2023, %o0
	add	%fp, 2015, %o1
	call	_ZNSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEC1ERKS2_, 0
	 nop
	ldx	[%fp+2023], %o0
	mov	%o0, %i0
	return	%i7+8
	nop
.LLFE141:
.LLfe141:
	.size	_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKl,.LLfe141-_ZNKSt17__normal_iteratorIPSt4pairIiSsESt6vectorIS1_SaIS1_EEEmiERKl
.section	".gnu.linkonce.t._ZSt8__medianISt4pairIiSsEERKT_S4_S4_S4_",#alloc,#execinstr
	.align 4
	.weak	_ZSt8__medianISt4pairIiSsEERKT_S4_S4_S4_
	.type	_ZSt8__medianISt4pairIiSsEERKT_S4_S4_S4_,#function
	.proc	0110
_ZSt8__medianISt4pairIiSsEERKT_S4_S4_S4_:
.LLFB142:
	!#PROLOGUE# 0
	save	%sp, -192, %sp
.LLCFI141:
	!#PROLOGUE# 1
	stx	%i0, [%fp+2175]
	stx	%i1, [%fp+2183]
	stx	%i2, [%fp+2191]
	ldx	[%fp+2175], %o0
	ldx	[%fp+2183], %o1
	call	_ZStltIiSsEbRKSt4pairIT_T0_ES5_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL600
	nop
	ldx	[%fp+2183], %o0
	ldx	[%fp+2191], %o1
	call	_ZStltIiSsEbRKSt4pairIT_T0_ES5_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL601
	nop
	ldx	[%fp+2183], %i0
	ba,pt	%xcc, .LL599
	 nop
.LL601:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2191], %o1
	call	_ZStltIiSsEbRKSt4pairIT_T0_ES5_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL603
	nop
	ldx	[%fp+2191], %i0
	ba,pt	%xcc, .LL599
	 nop
.LL603:
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL599
	 nop
.LL600:
	ldx	[%fp+2175], %o0
	ldx	[%fp+2191], %o1
	call	_ZStltIiSsEbRKSt4pairIT_T0_ES5_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL606
	nop
	ldx	[%fp+2175], %i0
	ba,pt	%xcc, .LL599
	 nop
.LL606:
	ldx	[%fp+2183], %o0
	ldx	[%fp+2191], %o1
	call	_ZStltIiSsEbRKSt4pairIT_T0_ES5_, 0
	 nop
	cmp	%o0, 0
	be	%icc, .LL608
	nop
	ldx	[%fp+2191], %i0
	ba,pt	%xcc, .LL599
	 nop
.LL608:
	ldx	[%fp+2183], %i0
.LL599:
	return	%i7+8
	nop
.LLFE142:
.LLfe142:
	.size	_ZSt8__medianISt4pairIiSsEERKT_S4_S4_S4_,.LLfe142-_ZSt8__medianISt4pairIiSsEERKT_S4_S4_S4_

>Fix:
>Release-Note:
>Audit-Trail:
>Unformatted:


^ permalink raw reply	[flat|nested] only message in thread

only message in thread, other threads:[~2001-08-27 12:06 UTC | newest]

Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2001-08-27 12:06 c++/4147: g++ 3.0.1 internal error with STL sbi

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).