From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 7175 invoked by alias); 7 Jul 2005 16:11:29 -0000 Mailing-List: contact gcc-bugs-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Archive: List-Post: List-Help: Sender: gcc-bugs-owner@gcc.gnu.org Received: (qmail 4996 invoked by uid 22791); 7 Jul 2005 16:08:44 -0000 Received: from sccrmhc14.comcast.net (HELO sccrmhc14.comcast.net) (204.127.202.59) by sourceware.org (qpsmtpd/0.30-dev) with ESMTP; Thu, 07 Jul 2005 16:08:44 +0000 Received: from smbear.site (c-24-7-126-191.hsd1.ca.comcast.net[24.7.126.191]) by comcast.net (sccrmhc14) with ESMTP id <2005070716080201400hnfs0e>; Thu, 7 Jul 2005 16:08:02 +0000 Received: by smbear.site (Postfix, from userid 1000) id ACDADD59C; Mon, 4 Jul 2005 14:52:06 -0700 (PDT) From: Gary To: gcc-bugs@gcc.gnu.org Subject: g++ v4.0.0 internal compiler error Reply-To: garynot@comcast.net Message-Id: <20050704215206.ACDADD59C@smbear.site> Date: Thu, 07 Jul 2005 16:11:00 -0000 X-SW-Source: 2005-07/txt/msg00770.txt.bz2 List-Id: g++ v4.0.0 internal compiler error, Target: i686-pc-cygwin Gary Barnes garynot@comcast.net g++ \ -v \ --save-temps \ -g \ -I/a/projects/geb/prolib.c++/test/safe/.pb/Cpp_Includes \ -MMD \ -ansi \ -pedantic \ -fshort-enums \ -W \ -Wall \ -Wundef \ -Wshadow \ -Wpointer-arith \ -Wcast-qual \ -Wcast-align \ -Wconversion \ -Wold-style-cast \ -Woverloaded-virtual \ -Wredundant-decls \ -Wsign-compare \ -Wsynth \ -Wwrite-strings \ -Winline \ -fmessage-length=99999 \ -Werror \ test_safe__variant.cc Using built-in specs. Target: i686-pc-cygwin Configured with: ../gcc-4.0.0/configure --prefix=/home/test --enable-languages=c,c++ Thread model: single gcc version 4.0.0 /home/test/libexec/gcc/i686-pc-cygwin/4.0.0/cc1plus.exe -E -quiet -v -I/a/projects/geb/prolib.c++/test/safe/.pb/Cpp_Includes -MMD test_safe__variant.d -D__CYGWIN32__ -D__CYGWIN__ -D__unix__ -D__unix -idirafter /usr/lib/../include/w32api -idirafter ../../include/w32api test_safe__variant.cc -mtune=pentiumpro -ansi -pedantic -W -Wall -Wundef -Wshadow -Wpointer-arith -Wcast-qual -Wcast-align -Wconversion -Wold-style-cast -Woverloaded-virtual -Wredundant-decls -Wsign-compare -Wsynth -Wwrite-strings -Winline -Werror -fshort-enums -fmessage-length=99999 -fworking-directory -fpch-preprocess -o test_safe__variant.ii ignoring nonexistent directory "/usr/local/include" ignoring nonexistent directory "/home/test/lib/gcc/i686-pc-cygwin/4.0.0/../../../../i686-pc-cygwin/include" ignoring nonexistent directory "../../include/w32api" #include "..." search starts here: #include <...> search starts here: /a/projects/geb/prolib.c++/test/safe/.pb/Cpp_Includes /home/test/lib/gcc/i686-pc-cygwin/4.0.0/../../../../include/c++/4.0.0 /home/test/lib/gcc/i686-pc-cygwin/4.0.0/../../../../include/c++/4.0.0/i686-pc-cygwin /home/test/lib/gcc/i686-pc-cygwin/4.0.0/../../../../include/c++/4.0.0/backward /home/test/include /home/test/lib/gcc/i686-pc-cygwin/4.0.0/include /usr/include /usr/lib/../include/w32api End of search list. /home/test/libexec/gcc/i686-pc-cygwin/4.0.0/cc1plus.exe -fpreprocessed test_safe__variant.ii -quiet -dumpbase test_safe__variant.cc -mtune=pentiumpro -ansi -auxbase test_safe__variant -g -pedantic -W -Wall -Wundef -Wshadow -Wpointer-arith -Wcast-qual -Wcast-align -Wconversion -Wold-style-cast -Woverloaded-virtual -Wredundant-decls -Wsign-compare -Wsynth -Wwrite-strings -Winline -Werror -ansi -version -fshort-enums -fmessage-length=99999 -o test_safe__variant.s GNU C++ version 4.0.0 (i686-pc-cygwin) compiled by GNU C version 4.0.0. GGC heuristics: --param ggc-min-expand=99 --param ggc-min-heapsize=130999 /a/projects/geb/prolib.c++/test/safe/.pb/Cpp_Includes/prolib.c++/safe/variant.hh: In instantiation of 'Pl::Safe::Base_Variant_t': test_safe__variant.cc:21: instantiated from here /a/projects/geb/prolib.c++/test/safe/.pb/Cpp_Includes/prolib.c++/safe/variant.hh:313: internal compiler error: in lookup_member, at cp/search.c:1209 Please submit a full bug report, with preprocessed source if appropriate. See for instructions. ============================================================================== -- Contents of test.ii are below. ============================================================================== namespace Pl { typedef int S_Addr_t; typedef unsigned int U_Addr_t; typedef S_Addr_t* S_Addr_p; typedef U_Addr_t* U_Addr_p; typedef char Char_t; typedef Char_t * Char_p; typedef const Char_t * Const_Char_p; template union Not_Constructed_t { double x; char a [sizeof (_Actual_t)]; _Actual_t & operator() () { auto _Actual_t * Ptr = reinterpret_cast <_Actual_t*> (&a [0]); return *Ptr; } template _Actual_t & Construct (_Constructor_t Actual) { auto _Actual_t * Ptr = new (&a [0]) _Actual_t (Actual); return *Ptr; } }; } namespace __gnu_debug_def { } namespace __gnu_debug { using namespace __gnu_debug_def; } namespace std { template class allocator; template struct char_traits; template, typename _Alloc = allocator<_CharT> > class basic_string; template<> struct char_traits; typedef basic_string string; } typedef int ptrdiff_t; typedef unsigned int size_t; namespace std { using ::ptrdiff_t; using ::size_t; } extern "C" { } extern "C" { typedef void *_LOCK_T; extern "C" { void __cygwin_lock_init(_LOCK_T *); void __cygwin_lock_init_recursive(_LOCK_T *); void __cygwin_lock_fini(_LOCK_T *); void __cygwin_lock_lock(_LOCK_T *); int __cygwin_lock_trylock(_LOCK_T *); void __cygwin_lock_unlock(_LOCK_T *); } typedef long _off_t; __extension__ typedef long long _off64_t; typedef int _ssize_t; typedef unsigned int wint_t; typedef struct { int __count; union { wint_t __wch; unsigned char __wchb[4]; } __value; } _mbstate_t; typedef _LOCK_T _flock_t; typedef void *_iconv_t; typedef unsigned long __ULong; struct _Bigint { struct _Bigint *_next; int _k, _maxwds, _sign, _wds; __ULong _x[1]; }; 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; }; struct _on_exit_args { void * _fnargs[32]; void * _dso_handle[32]; __ULong _fntypes; __ULong _is_cxa; }; struct _atexit { struct _atexit *_next; int _ind; void (*_fns[32])(void); struct _on_exit_args _on_exit_args; }; struct __sbuf { unsigned char *_base; int _size; }; typedef long _fpos_t; typedef _off64_t _fpos64_t; struct __sFILE { unsigned char *_p; int _r; int _w; short _flags; short _file; struct __sbuf _bf; int _lbfsize; void * _cookie; _ssize_t __attribute__((__cdecl__)) (*_read) (void * _cookie, char *_buf, int _n); _ssize_t __attribute__((__cdecl__)) (*_write) (void * _cookie, const char *_buf, int _n); _fpos_t __attribute__((__cdecl__)) (*_seek) (void * _cookie, _fpos_t _offset, int _whence); int __attribute__((__cdecl__)) (*_close) (void * _cookie); struct __sbuf _ub; unsigned char *_up; int _ur; unsigned char _ubuf[3]; unsigned char _nbuf[1]; struct __sbuf _lb; int _blksize; int _offset; struct _reent *_data; _flock_t _lock; }; struct __sFILE64 { unsigned char *_p; int _r; int _w; short _flags; short _file; struct __sbuf _bf; int _lbfsize; struct _reent *_data; void * _cookie; _ssize_t __attribute__((__cdecl__)) (*_read) (void * _cookie, char *_buf, int _n); _ssize_t __attribute__((__cdecl__)) (*_write) (void * _cookie, const char *_buf, int _n); _fpos_t __attribute__((__cdecl__)) (*_seek) (void * _cookie, _fpos_t _offset, int _whence); int __attribute__((__cdecl__)) (*_close) (void * _cookie); struct __sbuf _ub; unsigned char *_up; int _ur; unsigned char _ubuf[3]; unsigned char _nbuf[1]; struct __sbuf _lb; int _blksize; int _flags2; _off64_t _offset; _fpos64_t __attribute__((__cdecl__)) (*_seek64) (void * _cookie, _fpos64_t _offset, int _whence); _flock_t _lock; }; typedef struct __sFILE64 __FILE; struct _glue { struct _glue *_next; int _niobs; __FILE *_iobs; }; struct _rand48 { unsigned short _seed[3]; unsigned short _mult[3]; unsigned short _add; }; struct _reent { int _errno; __FILE *_stdin, *_stdout, *_stderr; int _inc; char _emergency[25]; int _current_category; const char *_current_locale; int __sdidinit; void __attribute__((__cdecl__)) (*__cleanup) (struct _reent *); struct _Bigint *_result; int _result_k; struct _Bigint *_p5s; struct _Bigint **_freelist; int _cvtlen; char *_cvtbuf; union { struct { unsigned int _unused_rand; char * _strtok_last; char _asctime_buf[26]; struct __tm _localtime_buf; int _gamma_signgam; __extension__ unsigned long long _rand_next; struct _rand48 _r48; _mbstate_t _mblen_state; _mbstate_t _mbtowc_state; _mbstate_t _wctomb_state; char _l64a_buf[8]; char _signal_buf[24]; int _getdate_err; _mbstate_t _mbrlen_state; _mbstate_t _mbrtowc_state; _mbstate_t _mbsrtowcs_state; _mbstate_t _wcrtomb_state; _mbstate_t _wcsrtombs_state; } _reent; struct { unsigned char * _nextf[30]; unsigned int _nmalloc[30]; } _unused; } _new; struct _atexit *_atexit; struct _atexit _atexit0; void (**(_sig_func))(int); struct _glue __sglue; __FILE __sf[3]; }; extern struct _reent *_impure_ptr ; extern struct _reent *const _global_impure_ptr ; void _reclaim_reent (struct _reent *); struct _reent * __attribute__((__cdecl__)) __getreent (void); } extern "C" { void * __attribute__((__cdecl__)) memchr (const void *, int, size_t); int __attribute__((__cdecl__)) memcmp (const void *, const void *, size_t); void * __attribute__((__cdecl__)) memcpy (void *, const void *, size_t); void * __attribute__((__cdecl__)) memmove (void *, const void *, size_t); void * __attribute__((__cdecl__)) memset (void *, int, size_t); char *__attribute__((__cdecl__)) strcat (char *, const char *); char *__attribute__((__cdecl__)) strchr (const char *, int); int __attribute__((__cdecl__)) strcmp (const char *, const char *); int __attribute__((__cdecl__)) strcoll (const char *, const char *); char *__attribute__((__cdecl__)) strcpy (char *, const char *); size_t __attribute__((__cdecl__)) strcspn (const char *, const char *); char *__attribute__((__cdecl__)) strerror (int); size_t __attribute__((__cdecl__)) strlen (const char *); char *__attribute__((__cdecl__)) strncat (char *, const char *, size_t); int __attribute__((__cdecl__)) strncmp (const char *, const char *, size_t); char *__attribute__((__cdecl__)) strncpy (char *, const char *, size_t); char *__attribute__((__cdecl__)) strpbrk (const char *, const char *); char *__attribute__((__cdecl__)) strrchr (const char *, int); size_t __attribute__((__cdecl__)) strspn (const char *, const char *); char *__attribute__((__cdecl__)) strstr (const char *, const char *); char *__attribute__((__cdecl__)) strtok (char *, const char *); size_t __attribute__((__cdecl__)) strxfrm (char *, const char *, size_t); } 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(__p), __c, __n); } using ::strchr; inline char* strchr(char* __s1, int __n) { return __builtin_strchr(const_cast(__s1), __n); } using ::strpbrk; inline char* strpbrk(char* __s1, const char* __s2) { return __builtin_strpbrk(const_cast(__s1), __s2); } using ::strrchr; inline char* strrchr(char* __s1, int __n) { return __builtin_strrchr(const_cast(__s1), __n); } using ::strstr; inline char* strstr(char* __s1, const char* __s2) { return __builtin_strstr(const_cast(__s1), __s2); } } extern "C" { } extern "C" { typedef struct { int quot; int rem; } div_t; typedef struct { long quot; long rem; } ldiv_t; extern __attribute__((dllimport)) int __mb_cur_max; void __attribute__((__cdecl__)) abort (void) __attribute__ ((noreturn)); int __attribute__((__cdecl__)) abs (int); int __attribute__((__cdecl__)) atexit (void (*__func)(void)); double __attribute__((__cdecl__)) atof (const char *__nptr); int __attribute__((__cdecl__)) atoi (const char *__nptr); int __attribute__((__cdecl__)) _atoi_r (struct _reent *, const char *__nptr); long __attribute__((__cdecl__)) atol (const char *__nptr); long __attribute__((__cdecl__)) _atol_r (struct _reent *, const char *__nptr); void * __attribute__((__cdecl__)) bsearch (const void * __key, const void * __base, size_t __nmemb, size_t __size, int (* __attribute__((__cdecl__)) _compar) (const void *, const void *)); void * __attribute__((__cdecl__)) calloc (size_t __nmemb, size_t __size); div_t __attribute__((__cdecl__)) div (int __numer, int __denom); void __attribute__((__cdecl__)) exit (int __status) __attribute__ ((noreturn)); void __attribute__((__cdecl__)) free (void *); char * __attribute__((__cdecl__)) getenv (const char *__string); char * __attribute__((__cdecl__)) _getenv_r (struct _reent *, const char *__string); const char *__attribute__((__cdecl__)) getprogname (void); char * __attribute__((__cdecl__)) _findenv (const char *, int *); char * __attribute__((__cdecl__)) _findenv_r (struct _reent *, const char *, int *); long __attribute__((__cdecl__)) labs (long); ldiv_t __attribute__((__cdecl__)) ldiv (long __numer, long __denom); void * __attribute__((__cdecl__)) malloc (size_t __size); int __attribute__((__cdecl__)) mblen (const char *, size_t); int __attribute__((__cdecl__)) _mblen_r (struct _reent *, const char *, size_t, _mbstate_t *); int __attribute__((__cdecl__)) mbtowc (wchar_t *, const char *, size_t); int __attribute__((__cdecl__)) _mbtowc_r (struct _reent *, wchar_t *, const char *, size_t, _mbstate_t *); int __attribute__((__cdecl__)) wctomb (char *, wchar_t); int __attribute__((__cdecl__)) _wctomb_r (struct _reent *, char *, wchar_t, _mbstate_t *); size_t __attribute__((__cdecl__)) mbstowcs (wchar_t *, const char *, size_t); size_t __attribute__((__cdecl__)) _mbstowcs_r (struct _reent *, wchar_t *, const char *, size_t, _mbstate_t *); size_t __attribute__((__cdecl__)) wcstombs (char *, const wchar_t *, size_t); size_t __attribute__((__cdecl__)) _wcstombs_r (struct _reent *, char *, const wchar_t *, size_t, _mbstate_t *); void __attribute__((__cdecl__)) qsort (void * __base, size_t __nmemb, size_t __size, int(*_compar)(const void *, const void *)); int __attribute__((__cdecl__)) rand (void); void * __attribute__((__cdecl__)) realloc (void * __r, size_t __size); void __attribute__((__cdecl__)) setprogname (const char *); void __attribute__((__cdecl__)) srand (unsigned __seed); double __attribute__((__cdecl__)) strtod (const char *__n, char **__end_PTR); double __attribute__((__cdecl__)) _strtod_r (struct _reent *,const char *__n, char **__end_PTR); float __attribute__((__cdecl__)) strtof (const char *__n, char **__end_PTR); long __attribute__((__cdecl__)) strtol (const char *__n, char **__end_PTR, int __base); long __attribute__((__cdecl__)) _strtol_r (struct _reent *,const char *__n, char **__end_PTR, int __base); unsigned long __attribute__((__cdecl__)) strtoul (const char *__n, char **__end_PTR, int __base); unsigned long __attribute__((__cdecl__)) _strtoul_r (struct _reent *,const char *__n, char **__end_PTR, int __base); int __attribute__((__cdecl__)) system (const char *__string); char * __attribute__((__cdecl__)) _dtoa_r (struct _reent *, double, int, int, int *, int*, char**); int __attribute__((__cdecl__)) _system_r (struct _reent *, const char *); void __attribute__((__cdecl__)) __eprintf (const char *, const char *, unsigned int, const char *); } 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; inline long abs(long __i) { return labs(__i); } inline ldiv_t div(long __i, long __j) { return ldiv(__i, __j); } } 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; }; char *__attribute__((__cdecl__)) setlocale (int category, const char *locale); struct lconv *__attribute__((__cdecl__)) localeconv (void); struct _reent; char *__attribute__((__cdecl__)) _setlocale_r (struct _reent *, int category, const char *locale); struct lconv *__attribute__((__cdecl__)) _localeconv_r (struct _reent *); } namespace std { using ::lconv; using ::setlocale; using ::localeconv; } typedef __builtin_va_list __gnuc_va_list; extern "C" { typedef signed char __int8_t ; typedef unsigned char __uint8_t ; typedef signed short __int16_t; typedef unsigned short __uint16_t; typedef __int16_t __int_least16_t; typedef __uint16_t __uint_least16_t; typedef signed int __int32_t; typedef unsigned int __uint32_t; typedef __int32_t __int_least32_t; typedef __uint32_t __uint_least32_t; typedef signed long long __int64_t; typedef unsigned long long __uint64_t; } typedef long int __off_t; typedef int __pid_t; __extension__ typedef long long int __loff_t; typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned int u_int; typedef unsigned long u_long; typedef unsigned short ushort; typedef unsigned int uint; typedef unsigned long clock_t; typedef long time_t; struct timespec { time_t tv_sec; long tv_nsec; }; struct itimerspec { struct timespec it_interval; struct timespec it_value; }; typedef long daddr_t; typedef char * caddr_t; typedef int pid_t; typedef _ssize_t ssize_t; typedef unsigned short nlink_t; typedef long fd_mask; typedef struct _types_fd_set { fd_mask fds_bits[(((64)+(((sizeof (fd_mask) * 8))-1))/((sizeof (fd_mask) * 8)))]; } _types_fd_set; typedef unsigned long clockid_t; typedef unsigned long timer_t; typedef long useconds_t; extern "C" { typedef signed char int8_t; typedef short int16_t; typedef long int32_t; typedef long long int64_t; typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned long uint32_t; typedef unsigned long long uint64_t; typedef signed char int_least8_t; typedef short int_least16_t; typedef long int_least32_t; typedef long long int_least64_t; typedef unsigned char uint_least8_t; typedef unsigned short uint_least16_t; typedef unsigned long uint_least32_t; typedef unsigned long long uint_least64_t; typedef signed char int_fast8_t; typedef long int_fast16_t; typedef long int_fast32_t; typedef long long int_fast64_t; typedef unsigned char uint_fast8_t; typedef unsigned long uint_fast16_t; typedef unsigned long uint_fast32_t; typedef unsigned long long uint_fast64_t; typedef long intptr_t; typedef unsigned long uintptr_t; typedef long long intmax_t; typedef unsigned long long uintmax_t; typedef struct timespec timespec_t; typedef struct timespec timestruc_t; typedef _off64_t off_t; typedef short __dev16_t; typedef unsigned long __dev32_t; typedef __dev32_t dev_t; typedef long blksize_t; typedef long __blkcnt32_t; typedef long long __blkcnt64_t; typedef __blkcnt64_t blkcnt_t; typedef unsigned long fsblkcnt_t; typedef unsigned long fsfilcnt_t; typedef unsigned short __uid16_t; typedef unsigned long __uid32_t; typedef __uid32_t uid_t; typedef unsigned short __gid16_t; typedef unsigned long __gid32_t; typedef __gid32_t gid_t; typedef unsigned long __ino32_t; typedef unsigned long long __ino64_t; typedef __ino64_t ino_t; typedef unsigned long id_t; struct flock { short l_type; short l_whence; off_t l_start; off_t l_len; pid_t l_pid; }; typedef long long key_t; typedef unsigned long vm_offset_t; typedef unsigned long vm_size_t; typedef void *vm_object_t; typedef unsigned char u_int8_t; typedef __uint16_t u_int16_t; typedef __uint32_t u_int32_t; typedef __uint64_t u_int64_t; typedef __int32_t register_t; typedef char *addr_t; typedef unsigned mode_t; typedef struct __pthread_t {char __dummy;} *pthread_t; typedef struct __pthread_mutex_t {char __dummy;} *pthread_mutex_t; typedef struct __pthread_key_t {char __dummy;} *pthread_key_t; typedef struct __pthread_attr_t {char __dummy;} *pthread_attr_t; typedef struct __pthread_mutexattr_t {char __dummy;} *pthread_mutexattr_t; typedef struct __pthread_condattr_t {char __dummy;} *pthread_condattr_t; typedef struct __pthread_cond_t {char __dummy;} *pthread_cond_t; typedef struct { pthread_mutex_t mutex; int state; } pthread_once_t; typedef struct __pthread_rwlock_t {char __dummy;} *pthread_rwlock_t; typedef struct __pthread_rwlockattr_t {char __dummy;} *pthread_rwlockattr_t; } extern "C" { typedef __FILE FILE; typedef _fpos64_t fpos_t; FILE * __attribute__((__cdecl__)) tmpfile (void); char * __attribute__((__cdecl__)) tmpnam (char *); int __attribute__((__cdecl__)) fclose (FILE *); int __attribute__((__cdecl__)) fflush (FILE *); FILE * __attribute__((__cdecl__)) freopen (const char *, const char *, FILE *); void __attribute__((__cdecl__)) setbuf (FILE *, char *); int __attribute__((__cdecl__)) setvbuf (FILE *, char *, int, size_t); int __attribute__((__cdecl__)) fprintf (FILE *, const char *, ...); int __attribute__((__cdecl__)) fscanf (FILE *, const char *, ...); int __attribute__((__cdecl__)) printf (const char *, ...); int __attribute__((__cdecl__)) scanf (const char *, ...); int __attribute__((__cdecl__)) sscanf (const char *, const char *, ...); int __attribute__((__cdecl__)) vfprintf (FILE *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) vprintf (const char *, __gnuc_va_list); int __attribute__((__cdecl__)) vsprintf (char *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) fgetc (FILE *); char * __attribute__((__cdecl__)) fgets (char *, int, FILE *); int __attribute__((__cdecl__)) fputc (int, FILE *); int __attribute__((__cdecl__)) fputs (const char *, FILE *); int __attribute__((__cdecl__)) getc (FILE *); int __attribute__((__cdecl__)) getchar (void); char * __attribute__((__cdecl__)) gets (char *); int __attribute__((__cdecl__)) putc (int, FILE *); int __attribute__((__cdecl__)) putchar (int); int __attribute__((__cdecl__)) puts (const char *); int __attribute__((__cdecl__)) ungetc (int, FILE *); size_t __attribute__((__cdecl__)) fread (void *, size_t _size, size_t _n, FILE *); size_t __attribute__((__cdecl__)) fwrite (const void * , size_t _size, size_t _n, FILE *); int __attribute__((__cdecl__)) fgetpos (FILE *, fpos_t *); int __attribute__((__cdecl__)) fseek (FILE *, long, int); int __attribute__((__cdecl__)) fsetpos (FILE *, const fpos_t *); long __attribute__((__cdecl__)) ftell ( FILE *); void __attribute__((__cdecl__)) rewind (FILE *); void __attribute__((__cdecl__)) clearerr (FILE *); int __attribute__((__cdecl__)) feof (FILE *); int __attribute__((__cdecl__)) ferror (FILE *); void __attribute__((__cdecl__)) perror (const char *); FILE * __attribute__((__cdecl__)) fopen (const char *_name, const char *_type); int __attribute__((__cdecl__)) sprintf (char *, const char *, ...); int __attribute__((__cdecl__)) remove (const char *); int __attribute__((__cdecl__)) rename (const char *, const char *); int __attribute__((__cdecl__)) _asiprintf_r (struct _reent *, char **, const char *, ...); int __attribute__((__cdecl__)) _asprintf_r (struct _reent *, char **, const char *, ...); int __attribute__((__cdecl__)) _fcloseall_r (struct _reent *); FILE * __attribute__((__cdecl__)) _fdopen_r (struct _reent *, int, const char *); FILE * __attribute__((__cdecl__)) _fopen_r (struct _reent *, const char *, const char *); int __attribute__((__cdecl__)) _fclose_r (struct _reent *, FILE *); int __attribute__((__cdecl__)) _fiscanf_r (struct _reent *, FILE *, const char *, ...); int __attribute__((__cdecl__)) _fscanf_r (struct _reent *, FILE *, const char *, ...); int __attribute__((__cdecl__)) _fseek_r (struct _reent *, FILE *, long, int); long __attribute__((__cdecl__)) _ftell_r (struct _reent *, FILE *); int __attribute__((__cdecl__)) _getchar_r (struct _reent *); char * __attribute__((__cdecl__)) _gets_r (struct _reent *, char *); int __attribute__((__cdecl__)) _iprintf_r (struct _reent *, const char *, ...); int __attribute__((__cdecl__)) _iscanf_r (struct _reent *, const char *, ...); int __attribute__((__cdecl__)) _mkstemp_r (struct _reent *, char *); char * __attribute__((__cdecl__)) _mktemp_r (struct _reent *, char *); void __attribute__((__cdecl__)) _perror_r (struct _reent *, const char *); int __attribute__((__cdecl__)) _printf_r (struct _reent *, const char *, ...); int __attribute__((__cdecl__)) _putchar_r (struct _reent *, int); int __attribute__((__cdecl__)) _puts_r (struct _reent *, const char *); int __attribute__((__cdecl__)) _remove_r (struct _reent *, const char *); int __attribute__((__cdecl__)) _rename_r (struct _reent *, const char *_old, const char *_new); int __attribute__((__cdecl__)) _scanf_r (struct _reent *, const char *, ...); int __attribute__((__cdecl__)) _siprintf_r (struct _reent *, char *, const char *, ...); int __attribute__((__cdecl__)) _siscanf_r (struct _reent *, const char *, const char *, ...); int __attribute__((__cdecl__)) _sniprintf_r (struct _reent *, char *, size_t, const char *, ...); int __attribute__((__cdecl__)) _snprintf_r (struct _reent *, char *, size_t, const char *, ...); int __attribute__((__cdecl__)) _sprintf_r (struct _reent *, char *, const char *, ...); int __attribute__((__cdecl__)) _sscanf_r (struct _reent *, const char *, const char *, ...); char * __attribute__((__cdecl__)) _tempnam_r (struct _reent *, const char *, const char *); FILE * __attribute__((__cdecl__)) _tmpfile_r (struct _reent *); char * __attribute__((__cdecl__)) _tmpnam_r (struct _reent *, char *); int __attribute__((__cdecl__)) _ungetc_r (struct _reent *, int, FILE *); int __attribute__((__cdecl__)) _vasiprintf_r (struct _reent *, char **, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vasprintf_r (struct _reent *, char **, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vfiprintf_r (struct _reent *, FILE *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vfprintf_r (struct _reent *, FILE *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _viprintf_r (struct _reent *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vprintf_r (struct _reent *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vsiprintf_r (struct _reent *, char *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vsprintf_r (struct _reent *, char *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vsniprintf_r (struct _reent *, char *, size_t, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vsnprintf_r (struct _reent *, char *, size_t, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vfiscanf_r (struct _reent *, FILE *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vfscanf_r (struct _reent *, FILE *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _viscanf_r (struct _reent *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vscanf_r (struct _reent *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vsscanf_r (struct _reent *, const char *, const char *, __gnuc_va_list); int __attribute__((__cdecl__)) _vsiscanf_r (struct _reent *, const char *, const char *, __gnuc_va_list); ssize_t __attribute__((__cdecl__)) __getdelim (char **, size_t *, int, FILE *); ssize_t __attribute__((__cdecl__)) __getline (char **, size_t *, FILE *); int __attribute__((__cdecl__)) __srget (FILE *); int __attribute__((__cdecl__)) __swbuf (int, FILE *); static __inline__ int __sgetc(FILE *__p) { int __c = (--(__p)->_r < 0 ? __srget(__p) : (int)(*(__p)->_p++)); if ((__p->_flags & 0x4000) && (__c == '\r')) { int __c2 = (--(__p)->_r < 0 ? __srget(__p) : (int)(*(__p)->_p++)); if (__c2 == '\n') __c = __c2; else ungetc(__c2, __p); } return __c; } } 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; } namespace std { typedef int* __c_locale; template int __convert_from_v(char* __out, const int __size __attribute__((__unused__)), const char* __fmt, _Tv __v, const __c_locale&, int __prec) { char* __old = std::setlocale(4, __null); char* __sav = __null; if (std::strcmp(__old, "C")) { __sav = new char[std::strlen(__old) + 1]; std::strcpy(__sav, __old); std::setlocale(4, "C"); } const int __ret = std::sprintf(__out, __fmt, __prec, __v); if (__sav) { std::setlocale(4, __sav); delete [] __sav; } return __ret; } } #pragma GCC visibility push(default) typedef int __gthread_mutex_t; typedef int __gthread_recursive_mutex_t; static inline int __gthread_active_p (void) { return 0; } static inline int __gthread_mutex_lock (__gthread_mutex_t * ) { return 0; } static inline int __gthread_mutex_trylock (__gthread_mutex_t * ) { return 0; } static inline int __gthread_mutex_unlock (__gthread_mutex_t * ) { return 0; } static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex) { return __gthread_mutex_lock (mutex); } static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex) { return __gthread_mutex_trylock (mutex); } static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex) { return __gthread_mutex_unlock (mutex); } #pragma GCC visibility pop namespace std { typedef __gthread_mutex_t __c_lock; typedef FILE __c_file; 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; }; } extern "C" { int __attribute__((__cdecl__)) isalnum(int); int __attribute__((__cdecl__)) isalpha(int); int __attribute__((__cdecl__)) iscntrl(int); int __attribute__((__cdecl__)) isdigit(int); int __attribute__((__cdecl__)) isgraph(int); int __attribute__((__cdecl__)) islower(int); int __attribute__((__cdecl__)) isprint(int); int __attribute__((__cdecl__)) ispunct(int); int __attribute__((__cdecl__)) isspace(int); int __attribute__((__cdecl__)) isupper(int); int __attribute__((__cdecl__)) isxdigit(int); int __attribute__((__cdecl__)) tolower(int); int __attribute__((__cdecl__)) toupper(int); extern const __attribute__((dllimport)) char _ctype_[]; } 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; } extern "C" { 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; }; clock_t __attribute__((__cdecl__)) clock (void); double __attribute__((__cdecl__)) difftime (time_t _time2, time_t _time1); time_t __attribute__((__cdecl__)) mktime (struct tm *_timeptr); time_t __attribute__((__cdecl__)) time (time_t *_timer); char *__attribute__((__cdecl__)) asctime (const struct tm *_tblock); char *__attribute__((__cdecl__)) ctime (const time_t *_time); struct tm *__attribute__((__cdecl__)) gmtime (const time_t *_timer); struct tm *__attribute__((__cdecl__)) localtime (const time_t *_timer); size_t __attribute__((__cdecl__)) strftime (char *_s, size_t _maxsize, const char *_fmt, const struct tm *_t); char *__attribute__((__cdecl__)) asctime_r (const struct tm *, char *); char *__attribute__((__cdecl__)) ctime_r (const time_t *, char *); struct tm *__attribute__((__cdecl__)) gmtime_r (const time_t *, struct tm *); struct tm *__attribute__((__cdecl__)) localtime_r (const time_t *, struct tm *); } extern "C" { } extern "C" { typedef unsigned long sigset_t; extern "C" { typedef union sigval { int sival_int; void *sival_ptr; } sigval_t; typedef struct sigevent { sigval_t sigev_value; int sigev_signo; int sigev_notify; void (*sigev_notify_function) (sigval_t); pthread_attr_t *sigev_notify_attributes; } sigevent_t; #pragma pack(push,4) typedef struct { int si_signo; int si_code; pid_t si_pid; uid_t si_uid; int si_errno; union { __uint32_t __pad[32]; union { struct { union { struct { timer_t si_tid; unsigned int si_overrun; }; sigval_t si_sigval; sigval_t si_value; }; }; }; struct { int si_status; clock_t si_utime; clock_t si_stime; }; void *si_addr; }; } siginfo_t; #pragma pack(pop) enum { SI_USER = 1, SI_ASYNCIO, SI_MESGQ, SI_TIMER, SI_QUEUE, SI_KERNEL, ILL_ILLOPC, ILL_ILLOPN, ILL_ILLADR, ILL_ILLTRP, ILL_PRVOPC, ILL_PRVREG, ILL_COPROC, ILL_BADSTK, FPE_INTDIV, FPE_INTOVF, FPE_FLTDIV, FPE_FLTOVF, FPE_FLTUND, FPE_FLTRES, FPE_FLTINV, FPE_FLTSUB, SEGV_MAPERR, SEGV_ACCERR, BUS_ADRALN, BUS_ADRERR, BUS_OBJERR, CLD_EXITED, CLD_KILLED, CLD_DUMPED, CLD_TRAPPED, CLD_STOPPED, CLD_CONTINUED }; enum { SIGEV_SIGNAL = 0, SIGEV_NONE, SIGEV_THREAD }; typedef void (*_sig_func_ptr)(int); struct sigaction { union { _sig_func_ptr sa_handler; void (*sa_sigaction) ( int, siginfo_t *, void * ); }; sigset_t sa_mask; int sa_flags; }; int sigwait (const sigset_t *, int *); int sigwaitinfo (const sigset_t *, siginfo_t *); int sighold (int); int sigqueue(pid_t, int, const union sigval); int siginterrupt (int, int); } int __attribute__((__cdecl__)) sigprocmask (int how, const sigset_t *set, sigset_t *oset); int __attribute__((__cdecl__)) pthread_sigmask (int how, const sigset_t *set, sigset_t *oset); int __attribute__((__cdecl__)) kill (int, int); int __attribute__((__cdecl__)) killpg (pid_t, int); int __attribute__((__cdecl__)) sigaction (int, const struct sigaction *, struct sigaction *); int __attribute__((__cdecl__)) sigaddset (sigset_t *, const int); int __attribute__((__cdecl__)) sigdelset (sigset_t *, const int); int __attribute__((__cdecl__)) sigismember (const sigset_t *, int); int __attribute__((__cdecl__)) sigfillset (sigset_t *); int __attribute__((__cdecl__)) sigemptyset (sigset_t *); int __attribute__((__cdecl__)) sigpending (sigset_t *); int __attribute__((__cdecl__)) sigsuspend (const sigset_t *); int __attribute__((__cdecl__)) sigpause (int); int __attribute__((__cdecl__)) pthread_kill (pthread_t thread, int sig); } extern "C" { typedef int sig_atomic_t; struct _reent; _sig_func_ptr __attribute__((__cdecl__)) _signal_r (struct _reent *, int, _sig_func_ptr); int __attribute__((__cdecl__)) _raise_r (struct _reent *, int); _sig_func_ptr __attribute__((__cdecl__)) signal (int, _sig_func_ptr); int __attribute__((__cdecl__)) raise (int); } extern "C" { int __attribute__((__cdecl__)) clock_settime (clockid_t clock_id, const struct timespec *tp); int __attribute__((__cdecl__)) clock_gettime (clockid_t clock_id, struct timespec *tp); int __attribute__((__cdecl__)) clock_getres (clockid_t clock_id, struct timespec *res); int __attribute__((__cdecl__)) timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid); int __attribute__((__cdecl__)) timer_delete (timer_t timerid); int __attribute__((__cdecl__)) timer_settime (timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue); int __attribute__((__cdecl__)) timer_gettime (timer_t timerid, struct itimerspec *value); int __attribute__((__cdecl__)) timer_getoverrun (timer_t timerid); int __attribute__((__cdecl__)) nanosleep (const struct timespec *rqtp, struct timespec *rmtp); } extern "C" { } 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; } extern "C" { typedef _mbstate_t mbstate_t; wint_t __attribute__((__cdecl__)) btowc (int); int __attribute__((__cdecl__)) wctob (wint_t); size_t __attribute__((__cdecl__)) mbrlen (const char * , size_t, mbstate_t *); size_t __attribute__((__cdecl__)) mbrtowc (wchar_t * , const char * , size_t, mbstate_t *); size_t __attribute__((__cdecl__)) _mbrtowc_r (struct _reent *, wchar_t * , const char * , size_t, mbstate_t *); int __attribute__((__cdecl__)) mbsinit (const mbstate_t *); size_t __attribute__((__cdecl__)) mbsrtowcs (wchar_t * , const char ** , size_t, mbstate_t *); size_t __attribute__((__cdecl__)) wcrtomb (char * , wchar_t, mbstate_t *); size_t __attribute__((__cdecl__)) _wcrtomb_r (struct _reent *, char * , wchar_t, mbstate_t *); size_t __attribute__((__cdecl__)) wcsrtombs (char * , const wchar_t ** , size_t, mbstate_t *); size_t __attribute__((__cdecl__)) _wcsrtombs_r (struct _reent *, char * , const wchar_t ** , size_t, mbstate_t *); wchar_t *__attribute__((__cdecl__)) wcscat (wchar_t * , const wchar_t *); wchar_t *__attribute__((__cdecl__)) wcschr (const wchar_t *, wchar_t); int __attribute__((__cdecl__)) wcscmp (const wchar_t *, const wchar_t *); int __attribute__((__cdecl__)) wcscoll (const wchar_t *, const wchar_t *); wchar_t *__attribute__((__cdecl__)) wcscpy (wchar_t * , const wchar_t *); size_t __attribute__((__cdecl__)) wcscspn (const wchar_t *, const wchar_t *); size_t __attribute__((__cdecl__)) wcslcat (wchar_t *, const wchar_t *, size_t); size_t __attribute__((__cdecl__)) wcslcpy (wchar_t *, const wchar_t *, size_t); size_t __attribute__((__cdecl__)) wcslen (const wchar_t *); wchar_t *__attribute__((__cdecl__)) wcsncat (wchar_t * , const wchar_t * , size_t); int __attribute__((__cdecl__)) wcsncmp (const wchar_t *, const wchar_t *, size_t); wchar_t *__attribute__((__cdecl__)) wcsncpy (wchar_t * , const wchar_t * , size_t); size_t __attribute__((__cdecl__)) wcsnlen (const wchar_t *, size_t); wchar_t *__attribute__((__cdecl__)) wcspbrk (const wchar_t *, const wchar_t *); wchar_t *__attribute__((__cdecl__)) wcsrchr (const wchar_t *, wchar_t); size_t __attribute__((__cdecl__)) wcsspn (const wchar_t *, const wchar_t *); wchar_t *__attribute__((__cdecl__)) wcsstr (const wchar_t *, const wchar_t *); int __attribute__((__cdecl__)) wcswidth (const wchar_t *, size_t); int __attribute__((__cdecl__)) wcwidth (const wchar_t); wchar_t *__attribute__((__cdecl__)) wmemchr (const wchar_t *, wchar_t, size_t); int __attribute__((__cdecl__)) wmemcmp (const wchar_t *, const wchar_t *, size_t); wchar_t *__attribute__((__cdecl__)) wmemcpy (wchar_t * , const wchar_t * , size_t); wchar_t *__attribute__((__cdecl__)) wmemmove (wchar_t *, const wchar_t *, size_t); wchar_t *__attribute__((__cdecl__)) wmemset (wchar_t *, wchar_t, size_t); } namespace std { using ::mbstate_t; } namespace std { typedef int64_t streamoff; typedef ptrdiff_t streamsize; template class fpos; template class fpos { private: streamoff _M_off; _StateT _M_state; public: fpos() : _M_off(0), _M_state() { } fpos(streamoff __off) : _M_off(__off), _M_state() { } operator streamoff() const { return _M_off; } void state(_StateT __st) { _M_state = __st; } _StateT state() const { return _M_state; } bool operator==(const fpos& __other) const { return _M_off == __other._M_off; } bool operator!=(const fpos& __other) const { return _M_off != __other._M_off; } fpos& operator+=(streamoff __off) { _M_off += __off; return *this; } fpos& operator-=(streamoff __off) { _M_off -= __off; return *this; } fpos operator+(streamoff __off) const { fpos __pos(*this); __pos += __off; return __pos; } fpos operator-(streamoff __off) const { fpos __pos(*this); __pos -= __off; return __pos; } streamoff operator-(const fpos& __other) const { return _M_off - __other._M_off; } }; typedef fpos streampos; typedef fpos wstreampos; } namespace std { void __throw_bad_exception(void) __attribute__((__noreturn__)); void __throw_bad_alloc(void) __attribute__((__noreturn__)); void __throw_bad_cast(void) __attribute__((__noreturn__)); void __throw_bad_typeid(void) __attribute__((__noreturn__)); void __throw_logic_error(const char* __s) __attribute__((__noreturn__)); void __throw_domain_error(const char* __s) __attribute__((__noreturn__)); void __throw_invalid_argument(const char* __s) __attribute__((__noreturn__)); void __throw_length_error(const char* __s) __attribute__((__noreturn__)); void __throw_out_of_range(const char* __s) __attribute__((__noreturn__)); void __throw_runtime_error(const char* __s) __attribute__((__noreturn__)); void __throw_range_error(const char* __s) __attribute__((__noreturn__)); void __throw_overflow_error(const char* __s) __attribute__((__noreturn__)); void __throw_underflow_error(const char* __s) __attribute__((__noreturn__)); void __throw_ios_failure(const char* __s) __attribute__((__noreturn__)); } namespace std { template > class basic_ios; template > class basic_streambuf; template > class basic_istream; template > class basic_ostream; template > class basic_iostream; template, typename _Alloc = allocator<_CharT> > class basic_stringbuf; template, typename _Alloc = allocator<_CharT> > class basic_istringstream; template, typename _Alloc = allocator<_CharT> > class basic_ostringstream; template, typename _Alloc = allocator<_CharT> > class basic_stringstream; template > class basic_filebuf; template > class basic_ifstream; template > class basic_ofstream; template > class basic_fstream; template > class istreambuf_iterator; template > class ostreambuf_iterator; class ios_base; typedef basic_ios ios; typedef basic_streambuf streambuf; typedef basic_istream istream; typedef basic_ostream ostream; typedef basic_iostream iostream; typedef basic_stringbuf stringbuf; typedef basic_istringstream istringstream; typedef basic_ostringstream ostringstream; typedef basic_stringstream stringstream; typedef basic_filebuf filebuf; typedef basic_ifstream ifstream; typedef basic_ofstream ofstream; typedef basic_fstream fstream; } namespace std { template 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 pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) { } }; template inline bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __x.first == __y.first && __x.second == __y.second; } template 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 inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__x == __y); } template inline bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __y < __x; } template inline bool operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__y < __x); } template inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__x < __y); } template inline pair<_T1, _T2> make_pair(_T1 __x, _T2 __y) { return pair<_T1, _T2>(__x, __y); } } namespace __gnu_internal { typedef char __one; typedef char __two[2]; template __one __test_type(int _Tp::*); template __two& __test_type(...); } namespace __gnu_cxx { template class __normal_iterator; } struct __true_type { }; struct __false_type { }; namespace std { template struct __truth_type { typedef __false_type __type; }; template<> struct __truth_type { typedef __true_type __type; }; template struct __traitor { enum { __value = _Sp::__value || _Tp::__value }; typedef typename __truth_type<__value>::__type __type; }; template struct __are_same { enum { __value = 0 }; typedef __false_type __type; }; template struct __are_same<_Tp, _Tp> { enum { __value = 1 }; typedef __true_type __type; }; template struct __enable_if { }; template struct __enable_if<_Tp, true> { typedef _Tp __type; }; template struct __is_void { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_void { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_integer { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_floating { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_pointer { enum { __value = 0 }; typedef __false_type __type; }; template struct __is_pointer<_Tp*> { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_normal_iterator { enum { __value = 0 }; typedef __false_type __type; }; template struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, _Container> > { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_arithmetic : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > { }; template struct __is_fundamental : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> > { }; template struct __is_scalar : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > { }; template struct __is_pod { enum { __value = (sizeof(__gnu_internal::__test_type<_Tp>(0)) != sizeof(__gnu_internal::__one)) }; }; } 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 struct iterator { typedef _Category iterator_category; typedef _Tp value_type; typedef _Distance difference_type; typedef _Pointer pointer; typedef _Reference reference; }; template 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 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 struct iterator_traits { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef const _Tp* pointer; typedef const _Tp& reference; }; template inline typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&) { return typename iterator_traits<_Iter>::iterator_category(); } } namespace std { template 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 inline typename iterator_traits<_RandomAccessIterator>::difference_type __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) { return __last - __first; } template inline typename iterator_traits<_InputIterator>::difference_type distance(_InputIterator __first, _InputIterator __last) { return std::__distance(__first, __last, std::__iterator_category(__first)); } template inline void __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) { while (__n--) ++__i; } template inline void __advance(_BidirectionalIterator& __i, _Distance __n, bidirectional_iterator_tag) { if (__n > 0) while (__n--) ++__i; else while (__n++) --__i; } template inline void __advance(_RandomAccessIterator& __i, _Distance __n, random_access_iterator_tag) { __i += __n; } template inline void advance(_InputIterator& __i, _Distance __n) { std::__advance(__i, __n, std::__iterator_category(__i)); } } namespace std { template class reverse_iterator : public iterator::iterator_category, typename iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::reference> { protected: _Iterator current; public: typedef _Iterator iterator_type; typedef typename iterator_traits<_Iterator>::difference_type difference_type; typedef typename iterator_traits<_Iterator>::reference reference; typedef typename iterator_traits<_Iterator>::pointer pointer; public: reverse_iterator() : current() { } explicit reverse_iterator(iterator_type __x) : current(__x) { } reverse_iterator(const reverse_iterator& __x) : current(__x.current) { } template 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*()); } reverse_iterator& operator++() { --current; return *this; } reverse_iterator operator++(int) { reverse_iterator __tmp = *this; --current; return __tmp; } reverse_iterator& operator--() { ++current; return *this; } reverse_iterator operator--(int) { reverse_iterator __tmp = *this; ++current; return __tmp; } reverse_iterator operator+(difference_type __n) const { return reverse_iterator(current - __n); } reverse_iterator& operator+=(difference_type __n) { current -= __n; return *this; } reverse_iterator operator-(difference_type __n) const { return reverse_iterator(current + __n); } reverse_iterator& operator-=(difference_type __n) { current += __n; return *this; } reference operator[](difference_type __n) const { return *(*this + __n); } }; template inline bool operator==(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __x.base() == __y.base(); } template inline bool operator<(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y.base() < __x.base(); } template inline bool operator!=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__x == __y); } template inline bool operator>(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y < __x; } template inline bool operator<=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__y < __x); } template inline bool operator>=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__x < __y); } template inline typename reverse_iterator<_Iterator>::difference_type operator-(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y.base() - __x.base(); } template 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 back_insert_iterator : public iterator { protected: _Container* container; public: typedef _Container container_type; explicit back_insert_iterator(_Container& __x) : container(&__x) { } back_insert_iterator& operator=(typename _Container::const_reference __value) { container->push_back(__value); return *this; } back_insert_iterator& operator*() { return *this; } back_insert_iterator& operator++() { return *this; } back_insert_iterator operator++(int) { return *this; } }; template inline back_insert_iterator<_Container> back_inserter(_Container& __x) { return back_insert_iterator<_Container>(__x); } template class front_insert_iterator : public iterator { protected: _Container* container; public: typedef _Container container_type; explicit front_insert_iterator(_Container& __x) : container(&__x) { } front_insert_iterator& operator=(typename _Container::const_reference __value) { container->push_front(__value); return *this; } front_insert_iterator& operator*() { return *this; } front_insert_iterator& operator++() { return *this; } front_insert_iterator operator++(int) { return *this; } }; template inline front_insert_iterator<_Container> front_inserter(_Container& __x) { return front_insert_iterator<_Container>(__x); } template class insert_iterator : public iterator { protected: _Container* container; typename _Container::iterator iter; public: typedef _Container container_type; insert_iterator(_Container& __x, typename _Container::iterator __i) : container(&__x), iter(__i) {} insert_iterator& operator=(const typename _Container::const_reference __value) { iter = container->insert(iter, __value); ++iter; return *this; } insert_iterator& operator*() { return *this; } insert_iterator& operator++() { return *this; } insert_iterator& operator++(int) { return *this; } }; template inline insert_iterator<_Container> inserter(_Container& __x, _Iterator __i) { return insert_iterator<_Container>(__x, typename _Container::iterator(__i)); } } namespace __gnu_cxx { using std::iterator_traits; using std::iterator; template class __normal_iterator { protected: _Iterator _M_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>::reference reference; typedef typename iterator_traits<_Iterator>::pointer pointer; __normal_iterator() : _M_current(_Iterator()) { } explicit __normal_iterator(const _Iterator& __i) : _M_current(__i) { } template 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& operator++() { ++_M_current; return *this; } __normal_iterator operator++(int) { return __normal_iterator(_M_current++); } __normal_iterator& operator--() { --_M_current; return *this; } __normal_iterator operator--(int) { return __normal_iterator(_M_current--); } reference operator[](const difference_type& __n) const { return _M_current[__n]; } __normal_iterator& operator+=(const difference_type& __n) { _M_current += __n; return *this; } __normal_iterator operator+(const difference_type& __n) const { return __normal_iterator(_M_current + __n); } __normal_iterator& operator-=(const difference_type& __n) { _M_current -= __n; return *this; } __normal_iterator operator-(const difference_type& __n) const { return __normal_iterator(_M_current - __n); } const _Iterator& base() const { return _M_current; } }; template inline bool operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { return __lhs.base() == __rhs.base(); } template inline bool operator==(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) { return __lhs.base() == __rhs.base(); } template inline bool operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { return __lhs.base() != __rhs.base(); } template inline bool operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) { return __lhs.base() != __rhs.base(); } template inline bool operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { return __lhs.base() < __rhs.base(); } template inline bool operator<(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) { return __lhs.base() < __rhs.base(); } template inline bool operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { return __lhs.base() > __rhs.base(); } template inline bool operator>(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) { return __lhs.base() > __rhs.base(); } template inline bool operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { return __lhs.base() <= __rhs.base(); } template inline bool operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) { return __lhs.base() <= __rhs.base(); } template inline bool operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { return __lhs.base() >= __rhs.base(); } template inline bool operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs) { return __lhs.base() >= __rhs.base(); } template inline typename __normal_iterator<_IteratorL, _Container>::difference_type operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { return __lhs.base() - __rhs.base(); } template 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); } } extern "C" { void __attribute__((__cdecl__)) __assert (const char *, int, const char *); } namespace __gnu_debug { template class _Safe_iterator; inline bool __check_singular_aux(const void*) { return false; } template inline bool __check_singular(_Iterator& __x) { return __gnu_debug::__check_singular_aux(&__x); } template inline bool __check_singular(const _Tp* __ptr) { return __ptr == 0; } template inline bool __check_singular(const _Safe_iterator<_Iterator, _Sequence>& __x) { return __x._M_singular(); } template inline bool __check_dereferenceable(_Iterator&) { return true; } template inline bool __check_dereferenceable(const _Tp* __ptr) { return __ptr; } template inline bool __check_dereferenceable(const _Safe_iterator<_Iterator, _Sequence>& __x) { return __x._M_dereferenceable(); } template inline bool __valid_range_aux2(const _RandomAccessIterator& __first, const _RandomAccessIterator& __last, std::random_access_iterator_tag) { return __last - __first >= 0; } template inline bool __valid_range_aux2(const _InputIterator&, const _InputIterator&, std::input_iterator_tag) { return true; } template inline bool __valid_range_aux(const _Integral&, const _Integral&, __true_type) { return true; } template inline bool __valid_range_aux(const _InputIterator& __first, const _InputIterator& __last, __false_type) { typedef typename std::iterator_traits<_InputIterator>::iterator_category _Category; return __gnu_debug::__valid_range_aux2(__first, __last, _Category()); } template inline bool __valid_range(const _InputIterator& __first, const _InputIterator& __last) { typedef typename std::__is_integer<_InputIterator>::__type _Integral; return __gnu_debug::__valid_range_aux(__first, __last, _Integral()); } template inline bool __valid_range(const _Safe_iterator<_Iterator, _Sequence>& __first, const _Safe_iterator<_Iterator, _Sequence>& __last) { return __first._M_valid_range(__last); } template inline _InputIterator __check_valid_range(const _InputIterator& __first, const _InputIterator& __last) { ; return __first; } template inline const _CharT* __check_string(const _CharT* __s, const _Integer& __n) { return __s; } template inline const _CharT* __check_string(const _CharT* __s) { return __s; } template inline bool __check_sorted_aux(const _InputIterator&, const _InputIterator&, std::input_iterator_tag) { return true; } template inline bool __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { if (__first == __last) return true; _ForwardIterator __next = __first; for (++__next; __next != __last; __first = __next, ++__next) { if (*__next < *__first) return false; } return true; } template inline bool __check_sorted_aux(const _InputIterator&, const _InputIterator&, _Predicate, std::input_iterator_tag) { return true; } template inline bool __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, std::forward_iterator_tag) { if (__first == __last) return true; _ForwardIterator __next = __first; for (++__next; __next != __last; __first = __next, ++__next) { if (__pred(*__next, *__first)) return false; } return true; } template inline bool __check_sorted(const _InputIterator& __first, const _InputIterator& __last) { typedef typename std::iterator_traits<_InputIterator>::iterator_category _Category; return __gnu_debug::__check_sorted_aux(__first, __last, _Category()); } template inline bool __check_sorted(const _InputIterator& __first, const _InputIterator& __last, _Predicate __pred) { typedef typename std::iterator_traits<_InputIterator>::iterator_category _Category; return __gnu_debug::__check_sorted_aux(__first, __last, __pred, _Category()); } template inline bool __check_partitioned(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { while (__first != __last && *__first < __value) ++__first; while (__first != __last && !(*__first < __value)) ++__first; return __first == __last; } template inline bool __check_partitioned(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Pred __pred) { while (__first != __last && __pred(*__first, __value)) ++__first; while (__first != __last && !__pred(*__first, __value)) ++__first; return __first == __last; } } namespace std { template inline void swap(_Tp& __a, _Tp& __b) { const _Tp __tmp = __a; __a = __b; __b = __tmp; } template struct __iter_swap { template static void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) { typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1; const _ValueType1 __tmp = *__a; *__a = *__b; *__b = __tmp; } }; template<> struct __iter_swap { template static void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) { swap(*__a, *__b); } }; template inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) { typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1; typedef typename iterator_traits<_ForwardIterator2>::value_type _ValueType2; typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1; typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2; std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value && __are_same<_ValueType1 &, _ReferenceType1>::__value && __are_same<_ValueType2 &, _ReferenceType2>::__value>:: iter_swap(__a, __b); } template inline const _Tp& min(const _Tp& __a, const _Tp& __b) { if (__b < __a) return __b; return __a; } template inline const _Tp& max(const _Tp& __a, const _Tp& __b) { if (__a < __b) return __b; return __a; } template inline const _Tp& min(const _Tp& __a, const _Tp& __b, _Compare __comp) { if (__comp(__b, __a)) return __b; return __a; } template inline const _Tp& max(const _Tp& __a, const _Tp& __b, _Compare __comp) { if (__comp(__a, __b)) return __b; return __a; } template struct __copy { template static _OI copy(_II __first, _II __last, _OI __result) { for (; __first != __last; ++__result, ++__first) *__result = *__first; return __result; } }; template struct __copy<_BoolType, random_access_iterator_tag> { template static _OI copy(_II __first, _II __last, _OI __result) { typedef typename iterator_traits<_II>::difference_type _Distance; for(_Distance __n = __last - __first; __n > 0; --__n) { *__result = *__first; ++__first; ++__result; } return __result; } }; template<> struct __copy { template static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) { std::memmove(__result, __first, sizeof(_Tp) * (__last - __first)); return __result + (__last - __first); } }; template inline _OI __copy_aux(_II __first, _II __last, _OI __result) { typedef typename iterator_traits<_II>::value_type _ValueTypeI; typedef typename iterator_traits<_OI>::value_type _ValueTypeO; typedef typename iterator_traits<_II>::iterator_category _Category; const bool __simple = (__is_scalar<_ValueTypeI>::__value && __is_pointer<_II>::__value && __is_pointer<_OI>::__value && __are_same<_ValueTypeI, _ValueTypeO>::__value); return std::__copy<__simple, _Category>::copy(__first, __last, __result); } template struct __copy_normal { template static _OI copy_n(_II __first, _II __last, _OI __result) { return std::__copy_aux(__first, __last, __result); } }; template<> struct __copy_normal { template static _OI copy_n(_II __first, _II __last, _OI __result) { return std::__copy_aux(__first.base(), __last.base(), __result); } }; template<> struct __copy_normal { template static _OI copy_n(_II __first, _II __last, _OI __result) { return _OI(std::__copy_aux(__first, __last, __result.base())); } }; template<> struct __copy_normal { template static _OI copy_n(_II __first, _II __last, _OI __result) { return _OI(std::__copy_aux(__first.base(), __last.base(), __result.base())); } }; template inline _OutputIterator copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { ; const bool __in = __is_normal_iterator<_InputIterator>::__value; const bool __out = __is_normal_iterator<_OutputIterator>::__value; return std::__copy_normal<__in, __out>::copy_n(__first, __last, __result); } template struct __copy_backward { template static _BI2 copy_b(_BI1 __first, _BI1 __last, _BI2 __result) { while (__first != __last) *--__result = *--__last; return __result; } }; template struct __copy_backward<_BoolType, random_access_iterator_tag> { template static _BI2 copy_b(_BI1 __first, _BI1 __last, _BI2 __result) { typename iterator_traits<_BI1>::difference_type __n; for (__n = __last - __first; __n > 0; --__n) *--__result = *--__last; return __result; } }; template<> struct __copy_backward { template static _Tp* copy_b(const _Tp* __first, const _Tp* __last, _Tp* __result) { const ptrdiff_t _Num = __last - __first; std::memmove(__result - _Num, __first, sizeof(_Tp) * _Num); return __result - _Num; } }; template inline _BI2 __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result) { typedef typename iterator_traits<_BI1>::value_type _ValueType1; typedef typename iterator_traits<_BI2>::value_type _ValueType2; typedef typename iterator_traits<_BI1>::iterator_category _Category; const bool __simple = (__is_scalar<_ValueType1>::__value && __is_pointer<_BI1>::__value && __is_pointer<_BI2>::__value && __are_same<_ValueType1, _ValueType2>::__value); return std::__copy_backward<__simple, _Category>::copy_b(__first, __last, __result); } template struct __copy_backward_normal { template static _BI2 copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result) { return std::__copy_backward_aux(__first, __last, __result); } }; template<> struct __copy_backward_normal { template static _BI2 copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result) { return std::__copy_backward_aux(__first.base(), __last.base(), __result); } }; template<> struct __copy_backward_normal { template static _BI2 copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result) { return _BI2(std::__copy_backward_aux(__first, __last, __result.base())); } }; template<> struct __copy_backward_normal { template static _BI2 copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result) { return _BI2(std::__copy_backward_aux(__first.base(), __last.base(), __result.base())); } }; template inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) { ; const bool __bi1 = __is_normal_iterator<_BI1>::__value; const bool __bi2 = __is_normal_iterator<_BI2>::__value; return std::__copy_backward_normal<__bi1, __bi2>::copy_b_n(__first, __last, __result); } template struct __fill { template static void fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { for (; __first != __last; ++__first) *__first = __value; } }; template<> struct __fill { template static void fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { const _Tp __tmp = __value; for (; __first != __last; ++__first) *__first = __tmp; } }; template void fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { ; const bool __scalar = __is_scalar<_Tp>::__value; std::__fill<__scalar>::fill(__first, __last, __value); } inline void fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c) { ; const unsigned char __tmp = __c; std::memset(__first, __tmp, __last - __first); } inline void fill(signed char* __first, signed char* __last, const signed char& __c) { ; const signed char __tmp = __c; std::memset(__first, static_cast(__tmp), __last - __first); } inline void fill(char* __first, char* __last, const char& __c) { ; const char __tmp = __c; std::memset(__first, static_cast(__tmp), __last - __first); } template struct __fill_n { template static _OutputIterator fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) { for (; __n > 0; --__n, ++__first) *__first = __value; return __first; } }; template<> struct __fill_n { template static _OutputIterator fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) { const _Tp __tmp = __value; for (; __n > 0; --__n, ++__first) *__first = __tmp; return __first; } }; template _OutputIterator fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) { const bool __scalar = __is_scalar<_Tp>::__value; return std::__fill_n<__scalar>::fill_n(__first, __n, __value); } template inline unsigned char* fill_n(unsigned char* __first, _Size __n, const unsigned char& __c) { std::fill(__first, __first + __n, __c); return __first + __n; } template inline signed char* fill_n(char* __first, _Size __n, const signed char& __c) { std::fill(__first, __first + __n, __c); return __first + __n; } template inline char* fill_n(char* __first, _Size __n, const char& __c) { std::fill(__first, __first + __n, __c); return __first + __n; } template pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) { ; while (__first1 != __last1 && *__first1 == *__first2) { ++__first1; ++__first2; } return pair<_InputIterator1, _InputIterator2>(__first1, __first2); } template pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred) { ; while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) { ++__first1; ++__first2; } return pair<_InputIterator1, _InputIterator2>(__first1, __first2); } template inline bool equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) { ; for (; __first1 != __last1; ++__first1, ++__first2) if (!(*__first1 == *__first2)) return false; return true; } template inline bool equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred) { ; for (; __first1 != __last1; ++__first1, ++__first2) if (!__binary_pred(*__first1, *__first2)) return false; return true; } template bool lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { ; ; for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) { if (*__first1 < *__first2) return true; if (*__first2 < *__first1) return false; } return __first1 == __last1 && __first2 != __last2; } template bool lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __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 = std::memcmp(__first1, __first2, std::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 std::lexicographical_compare((const signed char*) __first1, (const signed char*) __last1, (const signed char*) __first2, (const signed char*) __last2); } } namespace __gnu_cxx { template struct _Char_types { typedef unsigned long int_type; typedef std::streampos pos_type; typedef std::streamoff off_type; typedef std::mbstate_t state_type; }; template struct char_traits { typedef _CharT char_type; typedef typename _Char_types<_CharT>::int_type int_type; typedef typename _Char_types<_CharT>::pos_type pos_type; typedef typename _Char_types<_CharT>::off_type off_type; typedef typename _Char_types<_CharT>::state_type 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, std::size_t __n); static std::size_t length(const char_type* __s); static const char_type* find(const char_type* __s, std::size_t __n, const char_type& __a); static char_type* move(char_type* __s1, const char_type* __s2, std::size_t __n); static char_type* copy(char_type* __s1, const char_type* __s2, std::size_t __n); static char_type* assign(char_type* __s, std::size_t __n, char_type __a); static char_type to_char_type(const int_type& __c) { return static_cast(__c); } static int_type to_int_type(const char_type& __c) { return static_cast(__c); } static bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } static int_type eof() { return static_cast((-1)); } static int_type not_eof(const int_type& __c) { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } }; template int char_traits<_CharT>:: compare(const char_type* __s1, const char_type* __s2, std::size_t __n) { for (size_t __i = 0; __i < __n; ++__i) if (lt(__s1[__i], __s2[__i])) return -1; else if (lt(__s2[__i], __s1[__i])) return 1; return 0; } template std::size_t char_traits<_CharT>:: length(const char_type* __p) { std::size_t __i = 0; while (!eq(__p[__i], char_type())) ++__i; return __i; } template const typename char_traits<_CharT>::char_type* char_traits<_CharT>:: find(const char_type* __s, std::size_t __n, const char_type& __a) { for (std::size_t __i = 0; __i < __n; ++__i) if (eq(__s[__i], __a)) return __s + __i; return 0; } template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: move(char_type* __s1, const char_type* __s2, std::size_t __n) { return static_cast<_CharT*>(std::memmove(__s1, __s2, __n * sizeof(char_type))); } template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: copy(char_type* __s1, const char_type* __s2, std::size_t __n) { std::copy(__s2, __s2 + __n, __s1); return __s1; } template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: assign(char_type* __s, std::size_t __n, char_type __a) { std::fill_n(__s, __n, __a); return __s; } } namespace std { template struct char_traits : public __gnu_cxx::char_traits<_CharT> { }; template<> struct char_traits { 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(memchr(__s, __a, __n)); } static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) { return static_cast(memmove(__s1, __s2, __n)); } static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { return static_cast(memcpy(__s1, __s2, __n)); } static char_type* assign(char_type* __s, size_t __n, char_type __a) { return static_cast(memset(__s, __a, __n)); } static char_type to_char_type(const int_type& __c) { return static_cast(__c); } static int_type to_int_type(const char_type& __c) { return static_cast(static_cast(__c)); } static bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } static int_type eof() { return static_cast((-1)); } static int_type not_eof(const int_type& __c) { return (__c == eof()) ? 0 : __c; } }; } #pragma GCC visibility push(default) 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__)); bool uncaught_exception() throw(); } namespace __gnu_cxx { void __verbose_terminate_handler (); } } #pragma GCC visibility pop #pragma GCC visibility push(default) 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) throw(); } 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* __p) throw() { return __p; } inline void* operator new[](std::size_t, void* __p) throw() { return __p; } inline void operator delete (void*, void*) throw() { } inline void operator delete[](void*, void*) throw() { } } #pragma GCC visibility pop namespace __gnu_cxx { template class new_allocator { 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 struct rebind { typedef new_allocator<_Tp1> other; }; new_allocator() throw() { } new_allocator(const new_allocator&) throw() { } template new_allocator(const new_allocator<_Tp1>&) throw() { } ~new_allocator() throw() { } pointer address(reference __x) const { return &__x; } const_pointer address(const_reference __x) const { return &__x; } pointer allocate(size_type __n, const void* = 0) { if (__builtin_expect(__n > this->max_size(), false)) std::__throw_bad_alloc(); return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); } void deallocate(pointer __p, size_type) { ::operator delete(__p); } 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 inline bool operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&) { return true; } template inline bool operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&) { return false; } } namespace std { template class allocator; template<> class allocator { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; typedef void value_type; template struct rebind { typedef allocator<_Tp1> other; }; }; template class allocator: public __gnu_cxx::new_allocator<_Tp> { 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 struct rebind { typedef allocator<_Tp1> other; }; allocator() throw() { } allocator(const allocator& __a) throw() : __gnu_cxx::new_allocator<_Tp>(__a) { } template allocator(const allocator<_Tp1>&) throw() { } ~allocator() throw() { } }; template inline bool operator==(const allocator<_T1>&, const allocator<_T2>&) { return true; } template inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&) { return false; } extern template class allocator; extern template class allocator; } namespace std { template inline void _Construct(_T1* __p, const _T2& __value) { ::new(static_cast(__p)) _T1(__value); } template inline void _Construct(_T1* __p) { ::new(static_cast(__p)) _T1(); } template inline void _Destroy(_Tp* __pointer) { __pointer->~_Tp(); } template inline void __destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type) { for (; __first != __last; ++__first) std::_Destroy(&*__first); } template inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) { } template inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _Value_type; typedef typename std::__is_scalar<_Value_type>::__type _Has_trivial_destructor; std::__destroy_aux(__first, __last, _Has_trivial_destructor()); } template class allocator; template void _Destroy(_ForwardIterator __first, _ForwardIterator __last, _Allocator __alloc) { for (; __first != __last; ++__first) __alloc.destroy(&*__first); } template inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last, allocator<_Tp>) { _Destroy(__first, __last); } } namespace std { template inline _ForwardIterator __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, __true_type) { return std::copy(__first, __last, __result); } template inline _ForwardIterator __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, __false_type) { _ForwardIterator __cur = __result; try { for (; __first != __last; ++__first, ++__cur) std::_Construct(&*__cur, *__first); return __cur; } catch(...) { std::_Destroy(__result, __cur); throw; } } template inline _ForwardIterator uninitialized_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename std::__is_scalar<_ValueType>::__type _Is_POD; return std::__uninitialized_copy_aux(__first, __last, __result, _Is_POD()); } inline char* uninitialized_copy(const char* __first, const char* __last, char* __result) { std::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) { std::memmove(__result, __first, sizeof(wchar_t) * (__last - __first)); return __result + (__last - __first); } template inline void __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, __true_type) { std::fill(__first, __last, __x); } template void __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, __false_type) { _ForwardIterator __cur = __first; try { for (; __cur != __last; ++__cur) std::_Construct(&*__cur, __x); } catch(...) { std::_Destroy(__first, __cur); throw; } } template inline void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename std::__is_scalar<_ValueType>::__type _Is_POD; std::__uninitialized_fill_aux(__first, __last, __x, _Is_POD()); } template inline void __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n, const _Tp& __x, __true_type) { std::fill_n(__first, __n, __x); } template void __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n, const _Tp& __x, __false_type) { _ForwardIterator __cur = __first; try { for (; __n > 0; --__n, ++__cur) std::_Construct(&*__cur, __x); } catch(...) { std::_Destroy(__first, __cur); throw; } } template inline void uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename std::__is_scalar<_ValueType>::__type _Is_POD; std::__uninitialized_fill_n_aux(__first, __n, __x, _Is_POD()); } template _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator __alloc) { _ForwardIterator __cur = __result; try { for (; __first != __last; ++__first, ++__cur) __alloc.construct(&*__cur, *__first); return __cur; } catch(...) { std::_Destroy(__result, __cur, __alloc); throw; } } template inline _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, allocator<_Tp>) { return std::uninitialized_copy(__first, __last, __result); } template void __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, _Allocator __alloc) { _ForwardIterator __cur = __first; try { for (; __cur != __last; ++__cur) __alloc.construct(&*__cur, __x); } catch(...) { std::_Destroy(__first, __cur, __alloc); throw; } } template inline void __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, allocator<_Tp2>) { std::uninitialized_fill(__first, __last, __x); } template void __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, const _Tp& __x, _Allocator __alloc) { _ForwardIterator __cur = __first; try { for (; __n > 0; --__n, ++__cur) __alloc.construct(&*__cur, __x); } catch(...) { std::_Destroy(__first, __cur, __alloc); throw; } } template void __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, const _Tp& __x, allocator<_Tp2>) { std::uninitialized_fill_n(__first, __n, __x); } template inline _ForwardIterator __uninitialized_copy_copy(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _ForwardIterator __result, _Allocator __alloc) { _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, __result, __alloc); try { return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); } catch(...) { std::_Destroy(__result, __mid, __alloc); throw; } } template inline _ForwardIterator __uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid, const _Tp& __x, _InputIterator __first, _InputIterator __last, _Allocator __alloc) { std::__uninitialized_fill_a(__result, __mid, __x, __alloc); try { return std::__uninitialized_copy_a(__first, __last, __mid, __alloc); } catch(...) { std::_Destroy(__result, __mid, __alloc); throw; } } template inline void __uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, const _Tp& __x, _Allocator __alloc) { _ForwardIterator __mid2 = std::__uninitialized_copy_a(__first1, __last1, __first2, __alloc); try { std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); } catch(...) { std::_Destroy(__first2, __mid2, __alloc); throw; } } } namespace std { template class raw_storage_iterator : public iterator { protected: _ForwardIterator _M_iter; public: explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {} raw_storage_iterator& operator*() { return *this; } raw_storage_iterator& operator=(const _Tp& __element) { std::_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; } }; } 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 }; struct __numeric_limits_base { static const bool is_specialized = false; 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 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 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 struct numeric_limits : public __numeric_limits_base { static _Tp min() throw() { return static_cast<_Tp>(0); } static _Tp max() throw() { return static_cast<_Tp>(0); } static _Tp epsilon() throw() { return static_cast<_Tp>(0); } static _Tp round_error() throw() { return static_cast<_Tp>(0); } 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); } }; template<> struct numeric_limits { static const bool is_specialized = true; static bool min() throw() { return false; } static bool max() throw() { return true; } static const int digits = 1; static const int digits10 = 0; 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 = 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 { static const bool is_specialized = true; static char min() throw() { return (((char)(-1) < 0) ? (char)1 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); } static char max() throw() { return (((char)(-1) < 0) ? ((char)1 << (sizeof(char) * 8 - ((char)(-1) < 0))) - 1 : ~(char)0); } static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643 / 2136); static const bool is_signed = ((char)(-1) < 0); static const bool is_integer = true; static const bool is_exact = true; static const int radix = 2; static char epsilon() throw() { return 0; } static 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 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(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 { 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 = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); static const int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643 / 2136); 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(0); } static signed char quiet_NaN() throw() { return static_cast(0); } static signed char signaling_NaN() throw() { return static_cast(0); } static signed char denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static unsigned char min() throw() { return 0; } static unsigned char max() throw() { return 127 * 2U + 1; } static const int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); static const int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643 / 2136); 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(0); } static unsigned char quiet_NaN() throw() { return static_cast(0); } static unsigned char signaling_NaN() throw() { return static_cast(0); } static unsigned char denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static wchar_t min() throw() { return (((wchar_t)(-1) < 0) ? (wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); } static wchar_t max() throw() { return (((wchar_t)(-1) < 0) ? ((wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0))) - 1 : ~(wchar_t)0); } static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); static const int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643 / 2136); static const bool is_signed = ((wchar_t)(-1) < 0); 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 = 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 { static const bool is_specialized = true; static short min() throw() { return -32767 - 1; } static short max() throw() { return 32767; } static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643 / 2136); 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 = 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 { static const bool is_specialized = true; static unsigned short min() throw() { return 0; } static unsigned short max() throw() { return 32767 * 2U + 1; } static const int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); static const int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643 / 2136); 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(0); } static unsigned short quiet_NaN() throw() { return static_cast(0); } static unsigned short signaling_NaN() throw() { return static_cast(0); } static unsigned short denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static int min() throw() { return -2147483647 - 1; } static int max() throw() { return 2147483647; } static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643 / 2136); 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(0); } static int quiet_NaN() throw() { return static_cast(0); } static int signaling_NaN() throw() { return static_cast(0); } static int denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static unsigned int min() throw() { return 0; } static unsigned int max() throw() { return 2147483647 * 2U + 1; } static const int digits = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); static const int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643 / 2136); 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(0); } static unsigned int quiet_NaN() throw() { return static_cast(0); } static unsigned int signaling_NaN() throw() { return static_cast(0); } static unsigned int denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static long min() throw() { return -2147483647L - 1; } static long max() throw() { return 2147483647L; } static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643 / 2136); 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(0); } static long quiet_NaN() throw() { return static_cast(0); } static long signaling_NaN() throw() { return static_cast(0); } static long denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static unsigned long min() throw() { return 0; } static unsigned long max() throw() { return 2147483647L * 2UL + 1; } static const int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); static const int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643 / 2136); 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(0); } static unsigned long quiet_NaN() throw() { return static_cast(0); } static unsigned long signaling_NaN() throw() { return static_cast(0); } static unsigned long denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static long long min() throw() { return -9223372036854775807LL - 1; } static long long max() throw() { return 9223372036854775807LL; } static const int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0)); static const int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643 / 2136); 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 long epsilon() throw() { return 0; } static long 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 long infinity() throw() { return static_cast(0); } static long long quiet_NaN() throw() { return static_cast(0); } static long long signaling_NaN() throw() { return static_cast(0); } static long long denorm_min() throw() { return static_cast(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 { static const bool is_specialized = true; static unsigned long long min() throw() { return 0; } static unsigned long long max() throw() { return 9223372036854775807LL * 2ULL + 1; } static const int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); static const int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643 / 2136); 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 long epsilon() throw() { return 0; } static unsigned long 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 long infinity() throw() { return static_cast(0); } static unsigned long long quiet_NaN() throw() { return static_cast(0); } static unsigned long long signaling_NaN() throw() { return static_cast(0); } static unsigned long long denorm_min() throw() { return static_cast(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 { 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 1.19209290e-7F; } static float round_error() throw() { return 0.5F; } 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 = 1; static const bool has_quiet_NaN = 1; static const bool has_signaling_NaN = has_quiet_NaN; static const float_denorm_style has_denorm = bool(1.40129846e-45F) ? denorm_present : denorm_absent; static const bool has_denorm_loss = false; static float infinity() throw() { return __builtin_huge_valf (); } static float quiet_NaN() throw() { return __builtin_nanf (""); } static float signaling_NaN() throw() { return __builtin_nansf (""); } static float denorm_min() throw() { return 1.40129846e-45F; } static const bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 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_to_nearest; }; template<> struct numeric_limits { 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 0.5; } 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 = 1; static const bool has_quiet_NaN = 1; static const bool has_signaling_NaN = has_quiet_NaN; static const float_denorm_style has_denorm = bool(4.9406564584124654e-324) ? denorm_present : denorm_absent; static const bool has_denorm_loss = false; static double infinity() throw() { return __builtin_huge_val(); } static double quiet_NaN() throw() { return __builtin_nan (""); } static double signaling_NaN() throw() { return __builtin_nans (""); } static double denorm_min() throw() { return 4.9406564584124654e-324; } static const bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 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_to_nearest; }; template<> struct numeric_limits { static const bool is_specialized = true; static long double min() throw() { return 3.36210314311209350626e-4932L; } static long double max() throw() { return 1.18973149535723176502e+4932L; } static const int digits = 64; static const int digits10 = 18; 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.08420217248550443401e-19L; } static long double round_error() throw() { return 0.5L; } 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 = 1; static const bool has_quiet_NaN = 1; static const bool has_signaling_NaN = has_quiet_NaN; static const float_denorm_style has_denorm = bool(3.64519953188247460253e-4951L) ? denorm_present : denorm_absent; static const bool has_denorm_loss = false; static long double infinity() throw() { return __builtin_huge_vall (); } static long double quiet_NaN() throw() { return __builtin_nanl (""); } static long double signaling_NaN() throw() { return __builtin_nansl (""); } static long double denorm_min() throw() { return 3.64519953188247460253e-4951L; } static const bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; 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_to_nearest; }; } namespace std { template pair<_Tp*, ptrdiff_t> __get_temporary_buffer(ptrdiff_t __len, _Tp*) { const ptrdiff_t __max = numeric_limits::max() / sizeof(_Tp); if (__len > __max) __len = __max; while (__len > 0) { _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), nothrow)); if (__tmp != 0) return pair<_Tp*, ptrdiff_t>(__tmp, __len); __len /= 2; } return pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); } template inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) { return std::__get_temporary_buffer(__len, static_cast<_Tp*>(0)); } template void return_temporary_buffer(_Tp* __p) { ::operator delete(__p, nothrow); } template struct auto_ptr_ref { _Tp1* _M_ptr; explicit auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } }; template class auto_ptr { private: _Tp* _M_ptr; public: typedef _Tp element_type; explicit auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } template auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } auto_ptr& operator=(auto_ptr& __a) throw() { reset(__a.release()); return *this; } template auto_ptr& operator=(auto_ptr<_Tp1>& __a) throw() { reset(__a.release()); return *this; } ~auto_ptr() { delete _M_ptr; } element_type& operator*() const throw() { ; return *_M_ptr; } element_type* operator->() const throw() { ; return _M_ptr; } element_type* get() const throw() { return _M_ptr; } element_type* release() throw() { element_type* __tmp = _M_ptr; _M_ptr = 0; return __tmp; } void reset(element_type* __p = 0) throw() { if (__p != _M_ptr) { delete _M_ptr; _M_ptr = __p; } } auto_ptr(auto_ptr_ref __ref) throw() : _M_ptr(__ref._M_ptr) { } auto_ptr& operator=(auto_ptr_ref __ref) throw() { if (__ref._M_ptr != this->get()) { delete _M_ptr; _M_ptr = __ref._M_ptr; } return *this; } template operator auto_ptr_ref<_Tp1>() throw() { return auto_ptr_ref<_Tp1>(this->release()); } template operator auto_ptr<_Tp1>() throw() { return auto_ptr<_Tp1>(this->release()); } }; } namespace std { template struct unary_function { typedef _Arg argument_type; typedef _Result result_type; }; template struct binary_function { typedef _Arg1 first_argument_type; typedef _Arg2 second_argument_type; typedef _Result result_type; }; template struct plus : public binary_function<_Tp, _Tp, _Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; } }; template struct minus : public binary_function<_Tp, _Tp, _Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; } }; template struct multiplies : public binary_function<_Tp, _Tp, _Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; } }; template struct divides : public binary_function<_Tp, _Tp, _Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; } }; template struct modulus : public binary_function<_Tp, _Tp, _Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; } }; template struct negate : public unary_function<_Tp, _Tp> { _Tp operator()(const _Tp& __x) const { return -__x; } }; template struct equal_to : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; } }; template struct not_equal_to : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; } }; template struct greater : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; } }; template struct less : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; } }; template struct greater_equal : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; } }; template struct less_equal : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; } }; template struct logical_and : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; } }; template struct logical_or : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; } }; template struct logical_not : public unary_function<_Tp, bool> { bool operator()(const _Tp& __x) const { return !__x; } }; template class unary_negate : public unary_function { 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 inline unary_negate<_Predicate> not1(const _Predicate& __pred) { return unary_negate<_Predicate>(__pred); } template class binary_negate : public binary_function { 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 inline binary_negate<_Predicate> not2(const _Predicate& __pred) { return binary_negate<_Predicate>(__pred); } template class binder1st : public unary_function { 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 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 binder2nd : public unary_function { 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 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 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 inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg)) { return pointer_to_unary_function<_Arg, _Result>(__x); } template 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 inline pointer_to_binary_function<_Arg1, _Arg2, _Result> ptr_fun(_Result (*__x)(_Arg1, _Arg2)) { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } template struct _Identity : public unary_function<_Tp,_Tp> { _Tp& operator()(_Tp& __x) const { return __x; } const _Tp& operator()(const _Tp& __x) const { return __x; } }; template 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 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 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 const_mem_fun_t : public unary_function { 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 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 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 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 const_mem_fun1_t : public binary_function { 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 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 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 mem_fun_t : 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 const_mem_fun_t : public unary_function { 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 mem_fun_ref_t : 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 const_mem_fun_ref_t : 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 mem_fun1_t : 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 const_mem_fun1_t : public binary_function { 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 mem_fun1_ref_t : 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 const_mem_fun1_ref_t : 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 inline mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)()) { return mem_fun_t<_Ret, _Tp>(__f); } template inline const_mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)() const) { return const_mem_fun_t<_Ret, _Tp>(__f); } template inline mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)()) { return mem_fun_ref_t<_Ret, _Tp>(__f); } template 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 inline mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } template 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 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 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); } } typedef int _Atomic_word; namespace __gnu_cxx { _Atomic_word __attribute__ ((__unused__)) __exchange_and_add(volatile _Atomic_word* __mem, int __val); void __attribute__ ((__unused__)) __atomic_add(volatile _Atomic_word* __mem, int __val); } namespace std { template 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 __gnu_cxx::__normal_iterator iterator; typedef __gnu_cxx::__normal_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; private: struct _Rep_base { size_type _M_length; size_type _M_capacity; _Atomic_word _M_refcount; }; struct _Rep : _Rep_base { typedef typename _Alloc::template rebind::other _Raw_bytes_alloc; static const size_type _S_max_size; static const _CharT _S_terminal; static size_type _S_empty_rep_storage[]; static _Rep& _S_empty_rep() { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); } bool _M_is_leaked() const { return this->_M_refcount < 0; } bool _M_is_shared() const { return this->_M_refcount > 0; } void _M_set_leaked() { this->_M_refcount = -1; } void _M_set_sharable() { this->_M_refcount = 0; } void _M_set_length_and_sharable(size_type __n) { this->_M_set_sharable(); this->_M_length = __n; this->_M_refdata()[__n] = _S_terminal; } _CharT* _M_refdata() throw() { return reinterpret_cast<_CharT*>(this + 1); } _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_type, size_type, const _Alloc&); void _M_dispose(const _Alloc& __a) { if (__builtin_expect(this != &_S_empty_rep(), false)) if (__gnu_cxx::__exchange_and_add(&this->_M_refcount, -1) <= 0) _M_destroy(__a); } void _M_destroy(const _Alloc&) throw(); _CharT* _M_refcopy() throw() { if (__builtin_expect(this != &_S_empty_rep(), false)) __gnu_cxx::__atomic_add(&this->_M_refcount, 1); return _M_refdata(); } _CharT* _M_clone(const _Alloc&, size_type __res = 0); }; 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(-1); private: mutable _Alloc_hider _M_dataplus; _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(); } size_type _M_check(size_type __pos, const char* __s) const { if (__pos > this->size()) __throw_out_of_range((__s)); return __pos; } void _M_check_length(size_type __n1, size_type __n2, const char* __s) const { if (this->max_size() - (this->size() - __n1) < __n2) __throw_length_error((__s)); } size_type _M_limit(size_type __pos, size_type __off) const { const bool __testoff = __off < this->size() - __pos; return __testoff ? __off : this->size() - __pos; } bool _M_disjunct(const _CharT* __s) const { return (less()(__s, _M_data()) || less()(_M_data() + this->size(), __s)); } static void _M_copy(_CharT* __d, const _CharT* __s, size_type __n) { if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::copy(__d, __s, __n); } static void _M_move(_CharT* __d, const _CharT* __s, size_type __n) { if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::move(__d, __s, __n); } static void _M_assign(_CharT* __d, size_type __n, _CharT __c) { if (__n == 1) traits_type::assign(*__d, __c); else traits_type::assign(__d, __n, __c); } template 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) { _M_copy(__p, __k1, __k2 - __k1); } static void _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) { _M_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 _Rep::_S_empty_rep(); } 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 basic_string(_InputIterator __beg, _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) { this->assign(1, __c); return *this; } 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) { this->push_back(__c); return *this; } 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 basic_string& append(_InputIterator __first, _InputIterator __last) { return this->replace(_M_iend(), _M_iend(), __first, __last); } void push_back(_CharT __c) { const size_type __len = 1 + this->size(); if (__len > this->capacity() || _M_rep()->_M_is_shared()) this->reserve(__len); traits_type::assign(_M_data()[this->size()], __c); _M_rep()->_M_set_length_and_sharable(__len); } 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_data() + __str._M_check(__pos, "basic_string::assign"), __str._M_limit(__pos, __n)); } basic_string& assign(const _CharT* __s, size_type __n); basic_string& assign(const _CharT* __s) { ; return this->assign(__s, traits_type::length(__s)); } basic_string& assign(size_type __n, _CharT __c) { return _M_replace_aux(size_type(0), this->size(), __n, __c); } template 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 void insert(iterator __p, _InputIterator __beg, _InputIterator __end) { this->replace(__p, __p, __beg, __end); } basic_string& insert(size_type __pos1, const basic_string& __str) { return this->insert(__pos1, __str, size_type(0), __str.size()); } basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n) { return this->insert(__pos1, __str._M_data() + __str._M_check(__pos2, "basic_string::insert"), __str._M_limit(__pos2, __n)); } basic_string& insert(size_type __pos, const _CharT* __s, size_type __n); 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) { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), size_type(0), __n, __c); } iterator insert(iterator __p, _CharT __c) { ; const size_type __pos = __p - _M_ibegin(); _M_replace_aux(__pos, size_type(0), 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) { _M_mutate(_M_check(__pos, "basic_string::erase"), _M_limit(__pos, __n), size_type(0)); return *this; } iterator erase(iterator __position) { ; const size_type __pos = __position - _M_ibegin(); _M_mutate(__pos, size_type(1), size_type(0)); _M_rep()->_M_set_leaked(); return _M_ibegin() + __pos; } iterator erase(iterator __first, iterator __last) { ; const size_type __pos = __first - _M_ibegin(); _M_mutate(__pos, __last - __first, size_type(0)); _M_rep()->_M_set_leaked(); return _M_ibegin() + __pos; } basic_string& replace(size_type __pos, size_type __n, const basic_string& __str) { return this->replace(__pos, __n, __str._M_data(), __str.size()); } basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) { return this->replace(__pos1, __n1, __str._M_data() + __str._M_check(__pos2, "basic_string::replace"), __str._M_limit(__pos2, __n2)); } basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2); basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s) { ; return this->replace(__pos, __n1, __s, traits_type::length(__s)); } basic_string& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), _M_limit(__pos, __n1), __n2, __c); } basic_string& replace(iterator __i1, iterator __i2, const basic_string& __str) { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } basic_string& replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n) { ; return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); } basic_string& replace(iterator __i1, iterator __i2, const _CharT* __s) { ; return this->replace(__i1, __i2, __s, traits_type::length(__s)); } basic_string& replace(iterator __i1, iterator __i2, size_type __n, _CharT __c) { ; return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c); } template basic_string& replace(iterator __i1, iterator __i2, _InputIterator __k1, _InputIterator __k2) { ; ; typedef typename std::__is_integer<_InputIterator>::__type _Integral; return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral()); } basic_string& replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2) { ; ; return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1, __k2 - __k1); } basic_string& replace(iterator __i1, iterator __i2, const _CharT* __k1, const _CharT* __k2) { ; ; return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1, __k2 - __k1); } basic_string& replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2) { ; ; return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1.base(), __k2 - __k1); } basic_string& replace(iterator __i1, iterator __i2, const_iterator __k1, const_iterator __k2) { ; ; return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __k1.base(), __k2 - __k1); } private: template basic_string& _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n, _Integer __val, __true_type) { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); } template basic_string& _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, _InputIterator __k2, __false_type); basic_string& _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, _CharT __c); basic_string& _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2); template static _CharT* _S_construct_aux(_InIterator __beg, _InIterator __end, const _Alloc& __a, __false_type) { typedef typename iterator_traits<_InIterator>::iterator_category _Tag; return _S_construct(__beg, __end, __a, _Tag()); } template static _CharT* _S_construct_aux(_InIterator __beg, _InIterator __end, const _Alloc& __a, __true_type) { return _S_construct(static_cast(__beg), static_cast(__end), __a); } template static _CharT* _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a) { typedef typename std::__is_integer<_InIterator>::__type _Integral; return _S_construct_aux(__beg, __end, __a, _Integral()); } template static _CharT* _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, input_iterator_tag); template static _CharT* _S_construct(_FwdIterator __beg, _FwdIterator __end, 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& __s); const _CharT* c_str() const { 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 { return basic_string(*this, _M_check(__pos, "basic_string::substr"), __n); } int compare(const basic_string& __str) const { const size_type __size = this->size(); const size_type __osize = __str.size(); const size_type __len = std::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 inline basic_string<_CharT, _Traits, _Alloc>:: basic_string() : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { } template 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 basic_string<_CharT,_Traits,_Alloc> operator+(const _CharT* __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); template basic_string<_CharT,_Traits,_Alloc> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); template 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 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 inline bool operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) == 0; } template inline bool operator==(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) == 0; } template inline bool operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) == 0; } template inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) != 0; } template inline bool operator!=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) != 0; } template inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) != 0; } template inline bool operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) < 0; } template inline bool operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) < 0; } template inline bool operator<(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) > 0; } template inline bool operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) > 0; } template inline bool operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) > 0; } template inline bool operator>(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) < 0; } template inline bool operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) <= 0; } template inline bool operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) <= 0; } template inline bool operator<=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) >= 0; } template inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) >= 0; } template inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) >= 0; } template inline bool operator>=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) <= 0; } template inline void swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, basic_string<_CharT, _Traits, _Alloc>& __rhs) { __lhs.swap(__rhs); } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str); template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Alloc>& __str); template basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); template inline basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str); template<> basic_istream& getline(basic_istream& __in, basic_string& __str, char __delim); } namespace std { template bool __is_heap(_RandomAccessIterator __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 bool __is_heap(_RandomAccessIterator __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 bool __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { return std::__is_heap(__first, std::distance(__first, __last)); } template bool __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _StrictWeakOrdering __comp) { return std::__is_heap(__first, __comp, std::distance(__first, __last)); } template 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 inline void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; std::__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0), _ValueType(*(__last - 1))); } template 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 inline void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; ; std::__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0), _ValueType(*(__last - 1)), __comp); } template void __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, _Distance __len, _Tp __value) { const _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; } std::__push_heap(__first, __holeIndex, __topIndex, __value); } template inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __result, _Tp __value) { typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; *__result = *__first; std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value); } template inline void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; ; ; std::__pop_heap(__first, __last - 1, __last - 1, _ValueType(*(__last - 1))); } template void __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, _Distance __len, _Tp __value, _Compare __comp) { const _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; } std::__push_heap(__first, __holeIndex, __topIndex, __value, __comp); } template inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __result, _Tp __value, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; *__result = *__first; std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value, __comp); } template inline void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; std::__pop_heap(__first, __last - 1, __last - 1, _ValueType(*(__last - 1)), __comp); } template void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; if (__last - __first < 2) return; const _DistanceType __len = __last - __first; _DistanceType __parent = (__len - 2) / 2; while (true) { std::__adjust_heap(__first, __parent, __len, _ValueType(*(__first + __parent))); if (__parent == 0) return; __parent--; } } template inline void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; if (__last - __first < 2) return; const _DistanceType __len = __last - __first; _DistanceType __parent = (__len - 2) / 2; while (true) { std::__adjust_heap(__first, __parent, __len, _ValueType(*(__first + __parent)), __comp); if (__parent == 0) return; __parent--; } } template void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; while (__last - __first > 1) std::pop_heap(__first, __last--); } template void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; while (__last - __first > 1) std::pop_heap(__first, __last--, __comp); } } namespace std { template class _Temporary_buffer { public: typedef _Tp value_type; typedef value_type* pointer; typedef pointer iterator; typedef ptrdiff_t size_type; protected: size_type _M_original_len; size_type _M_len; pointer _M_buffer; void _M_initialize_buffer(const _Tp&, __true_type) { } void _M_initialize_buffer(const _Tp& val, __false_type) { std::uninitialized_fill_n(_M_buffer, _M_len, val); } public: size_type size() const { return _M_len; } size_type requested_size() const { return _M_original_len; } iterator begin() { return _M_buffer; } iterator end() { return _M_buffer + _M_len; } _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last); ~_Temporary_buffer() { std::_Destroy(_M_buffer, _M_buffer + _M_len); std::return_temporary_buffer(_M_buffer); } private: _Temporary_buffer(const _Temporary_buffer&); void operator=(const _Temporary_buffer&); }; template _Temporary_buffer<_ForwardIterator, _Tp>:: _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) : _M_original_len(std::distance(__first, __last)), _M_len(0), _M_buffer(0) { typedef typename std::__is_scalar<_Tp>::__type _Trivial; try { pair __p(get_temporary_buffer< value_type>(_M_original_len)); _M_buffer = __p.first; _M_len = __p.second; if (_M_len > 0) _M_initialize_buffer(*__first, _Trivial()); } catch(...) { std::return_temporary_buffer(_M_buffer); _M_buffer = 0; _M_len = 0; throw; } } } namespace std { template 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 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 _Function for_each(_InputIterator __first, _InputIterator __last, _Function __f) { ; for ( ; __first != __last; ++__first) __f(*__first); return __f; } template inline _InputIterator find(_InputIterator __first, _InputIterator __last, const _Tp& __val, input_iterator_tag) { while (__first != __last && !(*__first == __val)) ++__first; return __first; } template inline _InputIterator find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred, input_iterator_tag) { while (__first != __last && !__pred(*__first)) ++__first; return __first; } template _RandomAccessIterator find(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __val, random_access_iterator_tag) { typename iterator_traits<_RandomAccessIterator>::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 _RandomAccessIterator find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred, random_access_iterator_tag) { typename iterator_traits<_RandomAccessIterator>::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 inline _InputIterator find(_InputIterator __first, _InputIterator __last, const _Tp& __val) { ; return std::find(__first, __last, __val, std::__iterator_category(__first)); } template inline _InputIterator find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { ; return std::find_if(__first, __last, __pred, std::__iterator_category(__first)); } template _ForwardIterator adjacent_find(_ForwardIterator __first, _ForwardIterator __last) { ; if (__first == __last) return __last; _ForwardIterator __next = __first; while(++__next != __last) { if (*__first == *__next) return __first; __first = __next; } return __last; } template _ForwardIterator adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred) { ; if (__first == __last) return __last; _ForwardIterator __next = __first; while(++__next != __last) { if (__binary_pred(*__first, *__next)) return __first; __first = __next; } return __last; } template typename iterator_traits<_InputIterator>::difference_type count(_InputIterator __first, _InputIterator __last, const _Tp& __value) { ; typename iterator_traits<_InputIterator>::difference_type __n = 0; for ( ; __first != __last; ++__first) if (*__first == __value) ++__n; return __n; } template typename iterator_traits<_InputIterator>::difference_type count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { ; typename iterator_traits<_InputIterator>::difference_type __n = 0; for ( ; __first != __last; ++__first) if (__pred(*__first)) ++__n; return __n; } template _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { ; ; if (__first1 == __last1 || __first2 == __last2) return __first1; _ForwardIterator2 __tmp(__first2); ++__tmp; if (__tmp == __last2) return std::find(__first1, __last1, *__first2); _ForwardIterator2 __p1, __p; __p1 = __first2; ++__p1; _ForwardIterator1 __current = __first1; while (__first1 != __last1) { __first1 = std::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 _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __predicate) { ; ; if (__first1 == __last1 || __first2 == __last2) return __first1; _ForwardIterator2 __tmp(__first2); ++__tmp; if (__tmp == __last2) { while (__first1 != __last1 && !__predicate(*__first1, *__first2)) ++__first1; return __first1; } _ForwardIterator2 __p1, __p; __p1 = __first2; ++__p1; _ForwardIterator1 __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 _ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Integer __count, const _Tp& __val) { ; if (__count <= 0) return __first; else { __first = std::find(__first, __last, __val); while (__first != __last) { typename iterator_traits<_ForwardIterator>::difference_type __n = __count; _ForwardIterator __i = __first; ++__i; while (__i != __last && __n != 1 && *__i == __val) { ++__i; --__n; } if (__n == 1) return __first; else __first = std::find(__i, __last, __val); } return __last; } } template _ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Integer __count, const _Tp& __val, _BinaryPredicate __binary_pred) { ; if (__count <= 0) return __first; else { while (__first != __last) { if (__binary_pred(*__first, __val)) break; ++__first; } while (__first != __last) { typename iterator_traits<_ForwardIterator>::difference_type __n = __count; _ForwardIterator __i = __first; ++__i; while (__i != __last && __n != 1 && __binary_pred(*__i, __val)) { ++__i; --__n; } if (__n == 1) return __first; else { while (__i != __last) { if (__binary_pred(*__i, __val)) break; ++__i; } __first = __i; } } return __last; } } template _ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { ; for ( ; __first1 != __last1; ++__first1, ++__first2) std::iter_swap(__first1, __first2); return __first2; } template _OutputIterator transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __unary_op) { ; for ( ; __first != __last; ++__first, ++__result) *__result = __unary_op(*__first); return __result; } template _OutputIterator transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _OutputIterator __result, _BinaryOperation __binary_op) { ; for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result) *__result = __binary_op(*__first1, *__first2); return __result; } template void replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) { ; for ( ; __first != __last; ++__first) if (*__first == __old_value) *__first = __new_value; } template void replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) { ; for ( ; __first != __last; ++__first) if (__pred(*__first)) *__first = __new_value; } template _OutputIterator replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __old_value, const _Tp& __new_value) { ; for ( ; __first != __last; ++__first, ++__result) *__result = *__first == __old_value ? __new_value : *__first; return __result; } template _OutputIterator replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred, const _Tp& __new_value) { ; for ( ; __first != __last; ++__first, ++__result) *__result = __pred(*__first) ? __new_value : *__first; return __result; } template void generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) { ; for ( ; __first != __last; ++__first) *__first = __gen(); } template _OutputIterator generate_n(_OutputIterator __first, _Size __n, _Generator __gen) { for ( ; __n > 0; --__n, ++__first) *__first = __gen(); return __first; } template _OutputIterator remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value) { ; for ( ; __first != __last; ++__first) if (!(*__first == __value)) { *__result = *__first; ++__result; } return __result; } template _OutputIterator remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) { ; for ( ; __first != __last; ++__first) if (!__pred(*__first)) { *__result = *__first; ++__result; } return __result; } template _ForwardIterator remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { ; __first = std::find(__first, __last, __value); _ForwardIterator __i = __first; return __first == __last ? __first : std::remove_copy(++__i, __last, __first, __value); } template _ForwardIterator remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; __first = std::find_if(__first, __last, __pred); _ForwardIterator __i = __first; return __first == __last ? __first : std::remove_copy_if(++__i, __last, __first, __pred); } template _OutputIterator __unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, output_iterator_tag) { typename iterator_traits<_InputIterator>::value_type __value = *__first; *__result = __value; while (++__first != __last) if (!(__value == *__first)) { __value = *__first; *++__result = __value; } return ++__result; } template _ForwardIterator __unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, forward_iterator_tag) { *__result = *__first; while (++__first != __last) if (!(*__result == *__first)) *++__result = *__first; return ++__result; } template _OutputIterator __unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred, output_iterator_tag) { typename iterator_traits<_InputIterator>::value_type __value = *__first; *__result = __value; while (++__first != __last) if (!__binary_pred(__value, *__first)) { __value = *__first; *++__result = __value; } return ++__result; } template _ForwardIterator __unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __binary_pred, forward_iterator_tag) { *__result = *__first; while (++__first != __last) if (!__binary_pred(*__result, *__first)) *++__result = *__first; return ++__result; } template inline _OutputIterator unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { ; typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType; if (__first == __last) return __result; return std::__unique_copy(__first, __last, __result, _IterType()); } template inline _OutputIterator unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred) { ; typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType; if (__first == __last) return __result; return std::__unique_copy(__first, __last, __result, __binary_pred, _IterType()); } template _ForwardIterator unique(_ForwardIterator __first, _ForwardIterator __last) { ; __first = std::adjacent_find(__first, __last); if (__first == __last) return __last; _ForwardIterator __dest = __first; ++__first; while (++__first != __last) if (!(*__dest == *__first)) *++__dest = *__first; return ++__dest; } template _ForwardIterator unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred) { ; __first = std::adjacent_find(__first, __last, __binary_pred); if (__first == __last) return __last; _ForwardIterator __dest = __first; ++__first; while (++__first != __last) if (!__binary_pred(*__dest, *__first)) *++__dest = *__first; return ++__dest; } template void __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) { while (true) if (__first == __last || __first == --__last) return; else { std::iter_swap(__first, __last); ++__first; } } template void __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) { if (__first == __last) return; --__last; while (__first < __last) { std::iter_swap(__first, __last); ++__first; --__last; } } template inline void reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; std::__reverse(__first, __last, std::__iterator_category(__first)); } template _OutputIterator reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) { ; while (__first != __last) { --__last; *__result = *__last; ++__result; } return __result; } template _EuclideanRingElement __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) { while (__n != 0) { _EuclideanRingElement __t = __m % __n; __m = __n; __n = __t; } return __m; } template void __rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, forward_iterator_tag) { if (__first == __middle || __last == __middle) return; _ForwardIterator __first2 = __middle; do { swap(*__first, *__first2); ++__first; ++__first2; if (__first == __middle) __middle = __first2; } while (__first2 != __last); __first2 = __middle; while (__first2 != __last) { swap(*__first, *__first2); ++__first; ++__first2; if (__first == __middle) __middle = __first2; else if (__first2 == __last) __first2 = __middle; } } template void __rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, bidirectional_iterator_tag) { if (__first == __middle || __last == __middle) return; std::__reverse(__first, __middle, bidirectional_iterator_tag()); std::__reverse(__middle, __last, bidirectional_iterator_tag()); while (__first != __middle && __middle != __last) { swap(*__first, *--__last); ++__first; } if (__first == __middle) std::__reverse(__middle, __last, bidirectional_iterator_tag()); else std::__reverse(__first, __middle, bidirectional_iterator_tag()); } template void __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, random_access_iterator_tag) { if (__first == __middle || __last == __middle) return; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; const _Distance __n = __last - __first; const _Distance __k = __middle - __first; const _Distance __l = __n - __k; if (__k == __l) { std::swap_ranges(__first, __middle, __middle); return; } const _Distance __d = __gcd(__n, __k); for (_Distance __i = 0; __i < __d; __i++) { const _ValueType __tmp = *__first; _RandomAccessIterator __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; } } template inline void rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) { ; ; typedef typename iterator_traits<_ForwardIterator>::iterator_category _IterType; std::__rotate(__first, __middle, __last, _IterType()); } template _OutputIterator rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) { ; ; return std::copy(__first, __middle, copy(__middle, __last, __result)); } template inline void random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; if (__first != __last) for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1))); } template void random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomNumberGenerator& __rand) { ; if (__first == __last) return; for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) std::iter_swap(__i, __first + __rand((__i - __first) + 1)); } template _ForwardIterator __partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag) { if (__first == __last) return __first; while (__pred(*__first)) if (++__first == __last) return __first; _ForwardIterator __next = __first; while (++__next != __last) if (__pred(*__next)) { swap(*__first, *__next); ++__first; } return __first; } template _BidirectionalIterator __partition(_BidirectionalIterator __first, _BidirectionalIterator __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; std::iter_swap(__first, __last); ++__first; } } template inline _ForwardIterator partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; return std::__partition(__first, __last, __pred, std::__iterator_category(__first)); } template _ForwardIterator __inplace_stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _Distance __len) { if (__len == 1) return __pred(*__first) ? __last : __first; _ForwardIterator __middle = __first; std::advance(__middle, __len / 2); _ForwardIterator __begin = std::__inplace_stable_partition(__first, __middle, __pred, __len / 2); _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last, __pred, __len - __len / 2); std::rotate(__begin, __middle, __end); std::advance(__begin, std::distance(__middle, __end)); return __begin; } template _ForwardIterator __stable_partition_adaptive(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _Distance __len, _Pointer __buffer, _Distance __buffer_size) { if (__len <= __buffer_size) { _ForwardIterator __result1 = __first; _Pointer __result2 = __buffer; for ( ; __first != __last ; ++__first) if (__pred(*__first)) { *__result1 = *__first; ++__result1; } else { *__result2 = *__first; ++__result2; } std::copy(__buffer, __result2, __result1); return __result1; } else { _ForwardIterator __middle = __first; std::advance(__middle, __len / 2); _ForwardIterator __begin = std::__stable_partition_adaptive(__first, __middle, __pred, __len / 2, __buffer, __buffer_size); _ForwardIterator __end = std::__stable_partition_adaptive(__middle, __last, __pred, __len - __len / 2, __buffer, __buffer_size); std::rotate(__begin, __middle, __end); std::advance(__begin, std::distance(__middle, __end)); return __begin; } } template _ForwardIterator stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; if (__first == __last) return __first; else { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last); if (__buf.size() > 0) return std::__stable_partition_adaptive(__first, __last, __pred, _DistanceType(__buf.requested_size()), __buf.begin(), __buf.size()); else return std::__inplace_stable_partition(__first, __last, __pred, _DistanceType(__buf.requested_size())); } } template _RandomAccessIterator __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last, _Tp __pivot) { while (true) { while (*__first < __pivot) ++__first; --__last; while (__pivot < *__last) --__last; if (!(__first < __last)) return __first; std::iter_swap(__first, __last); ++__first; } } template _RandomAccessIterator __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last, _Tp __pivot, _Compare __comp) { while (true) { while (__comp(*__first, __pivot)) ++__first; --__last; while (__comp(__pivot, *__last)) --__last; if (!(__first < __last)) return __first; std::iter_swap(__first, __last); ++__first; } } enum { _S_threshold = 16 }; template void __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val) { _RandomAccessIterator __next = __last; --__next; while (__val < *__next) { *__last = *__next; __last = __next; --__next; } *__last = __val; } template void __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val, _Compare __comp) { _RandomAccessIterator __next = __last; --__next; while (__comp(__val, *__next)) { *__last = *__next; __last = __next; --__next; } *__last = __val; } template void __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { if (__first == __last) return; for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) { typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i; if (__val < *__first) { std::copy_backward(__first, __i, __i + 1); *__first = __val; } else std::__unguarded_linear_insert(__i, __val); } } template void __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { if (__first == __last) return; for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) { typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i; if (__comp(__val, *__first)) { std::copy_backward(__first, __i, __i + 1); *__first = __val; } else std::__unguarded_linear_insert(__i, __val, __comp); } } template inline void __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; for (_RandomAccessIterator __i = __first; __i != __last; ++__i) std::__unguarded_linear_insert(__i, _ValueType(*__i)); } template inline void __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; for (_RandomAccessIterator __i = __first; __i != __last; ++__i) std::__unguarded_linear_insert(__i, _ValueType(*__i), __comp); } template void __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { if (__last - __first > _S_threshold) { std::__insertion_sort(__first, __first + _S_threshold); std::__unguarded_insertion_sort(__first + _S_threshold, __last); } else std::__insertion_sort(__first, __last); } template void __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { if (__last - __first > _S_threshold) { std::__insertion_sort(__first, __first + _S_threshold, __comp); std::__unguarded_insertion_sort(__first + _S_threshold, __last, __comp); } else std::__insertion_sort(__first, __last, __comp); } template inline _Size __lg(_Size __n) { _Size __k; for (__k = 0; __n != 1; __n >>= 1) ++__k; return __k; } template void partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; ; ; std::make_heap(__first, __middle); for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) if (*__i < *__first) std::__pop_heap(__first, __middle, __i, _ValueType(*__i)); std::sort_heap(__first, __middle); } template void partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; ; ; std::make_heap(__first, __middle, __comp); for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) if (__comp(*__i, *__first)) std::__pop_heap(__first, __middle, __i, _ValueType(*__i), __comp); std::sort_heap(__first, __middle, __comp); } template _RandomAccessIterator partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) { typedef typename iterator_traits<_InputIterator>::value_type _InputValueType; typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; ; if (__result_first == __result_last) return __result_last; _RandomAccessIterator __result_real_last = __result_first; while(__first != __last && __result_real_last != __result_last) { *__result_real_last = *__first; ++__result_real_last; ++__first; } std::make_heap(__result_first, __result_real_last); while (__first != __last) { if (*__first < *__result_first) std::__adjust_heap(__result_first, _DistanceType(0), _DistanceType(__result_real_last - __result_first), _InputValueType(*__first)); ++__first; } std::sort_heap(__result_first, __result_real_last); return __result_real_last; } template _RandomAccessIterator partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) { typedef typename iterator_traits<_InputIterator>::value_type _InputValueType; typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; ; if (__result_first == __result_last) return __result_last; _RandomAccessIterator __result_real_last = __result_first; while(__first != __last && __result_real_last != __result_last) { *__result_real_last = *__first; ++__result_real_last; ++__first; } std::make_heap(__result_first, __result_real_last, __comp); while (__first != __last) { if (__comp(*__first, *__result_first)) std::__adjust_heap(__result_first, _DistanceType(0), _DistanceType(__result_real_last - __result_first), _InputValueType(*__first), __comp); ++__first; } std::sort_heap(__result_first, __result_real_last, __comp); return __result_real_last; } template void __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last, _Size __depth_limit) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; while (__last - __first > _S_threshold) { if (__depth_limit == 0) { std::partial_sort(__first, __last, __last); return; } --__depth_limit; _RandomAccessIterator __cut = std::__unguarded_partition(__first, __last, _ValueType(std::__median(*__first, *(__first + (__last - __first) / 2), *(__last - 1)))); std::__introsort_loop(__cut, __last, __depth_limit); __last = __cut; } } template void __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; while (__last - __first > _S_threshold) { if (__depth_limit == 0) { std::partial_sort(__first, __last, __last, __comp); return; } --__depth_limit; _RandomAccessIterator __cut = std::__unguarded_partition(__first, __last, _ValueType(std::__median(*__first, *(__first + (__last - __first) / 2), *(__last - 1), __comp)), __comp); std::__introsort_loop(__cut, __last, __depth_limit, __comp); __last = __cut; } } template inline void sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; ; if (__first != __last) { std::__introsort_loop(__first, __last, __lg(__last - __first) * 2); std::__final_insertion_sort(__first, __last); } } template inline void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; ; if (__first != __last) { std::__introsort_loop(__first, __last, __lg(__last - __first) * 2, __comp); std::__final_insertion_sort(__first, __last, __comp); } } template _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; ; _DistanceType __len = std::distance(__first, __last); _DistanceType __half; _ForwardIterator __middle; while (__len > 0) { __half = __len >> 1; __middle = __first; std::advance(__middle, __half); if (*__middle < __val) { __first = __middle; ++__first; __len = __len - __half - 1; } else __len = __half; } return __first; } template _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; ; _DistanceType __len = std::distance(__first, __last); _DistanceType __half; _ForwardIterator __middle; while (__len > 0) { __half = __len >> 1; __middle = __first; std::advance(__middle, __half); if (__comp(*__middle, __val)) { __first = __middle; ++__first; __len = __len - __half - 1; } else __len = __half; } return __first; } template _ForwardIterator upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; ; _DistanceType __len = std::distance(__first, __last); _DistanceType __half; _ForwardIterator __middle; while (__len > 0) { __half = __len >> 1; __middle = __first; std::advance(__middle, __half); if (__val < *__middle) __len = __half; else { __first = __middle; ++__first; __len = __len - __half - 1; } } return __first; } template _ForwardIterator upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; ; _DistanceType __len = std::distance(__first, __last); _DistanceType __half; _ForwardIterator __middle; while (__len > 0) { __half = __len >> 1; __middle = __first; std::advance(__middle, __half); if (__comp(__val, *__middle)) __len = __half; else { __first = __middle; ++__first; __len = __len - __half - 1; } } return __first; } template void __merge_without_buffer(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2) { if (__len1 == 0 || __len2 == 0) return; if (__len1 + __len2 == 2) { if (*__middle < *__first) std::iter_swap(__first, __middle); return; } _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::lower_bound(__middle, __last, *__first_cut); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::upper_bound(__first, __middle, *__second_cut); __len11 = std::distance(__first, __first_cut); } std::rotate(__first_cut, __middle, __second_cut); _BidirectionalIterator __new_middle = __first_cut; std::advance(__new_middle, std::distance(__middle, __second_cut)); std::__merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22); std::__merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11, __len2 - __len22); } template void __merge_without_buffer(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Compare __comp) { if (__len1 == 0 || __len2 == 0) return; if (__len1 + __len2 == 2) { if (__comp(*__middle, *__first)) std::iter_swap(__first, __middle); return; } _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::lower_bound(__middle, __last, *__first_cut, __comp); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::upper_bound(__first, __middle, *__second_cut, __comp); __len11 = std::distance(__first, __first_cut); } std::rotate(__first_cut, __middle, __second_cut); _BidirectionalIterator __new_middle = __first_cut; std::advance(__new_middle, std::distance(__middle, __second_cut)); std::__merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22, __comp); std::__merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11, __len2 - __len22, __comp); } template void __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { if (__last - __first < 15) { std::__insertion_sort(__first, __last); return; } _RandomAccessIterator __middle = __first + (__last - __first) / 2; std::__inplace_stable_sort(__first, __middle); std::__inplace_stable_sort(__middle, __last); std::__merge_without_buffer(__first, __middle, __last, __middle - __first, __last - __middle); } template void __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { if (__last - __first < 15) { std::__insertion_sort(__first, __last, __comp); return; } _RandomAccessIterator __middle = __first + (__last - __first) / 2; std::__inplace_stable_sort(__first, __middle, __comp); std::__inplace_stable_sort(__middle, __last, __comp); std::__merge_without_buffer(__first, __middle, __last, __middle - __first, __last - __middle, __comp); } template _OutputIterator merge(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; while (__first1 != __last1 && __first2 != __last2) { if (*__first2 < *__first1) { *__result = *__first2; ++__first2; } else { *__result = *__first1; ++__first1; } ++__result; } return std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } template _OutputIterator merge(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; while (__first1 != __last1 && __first2 != __last2) { if (__comp(*__first2, *__first1)) { *__result = *__first2; ++__first2; } else { *__result = *__first1; ++__first1; } ++__result; } return std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } template void __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator2 __result, _Distance __step_size) { const _Distance __two_step = 2 * __step_size; while (__last - __first >= __two_step) { __result = std::merge(__first, __first + __step_size, __first + __step_size, __first + __two_step, __result); __first += __two_step; } __step_size = std::min(_Distance(__last - __first), __step_size); std::merge(__first, __first + __step_size, __first + __step_size, __last, __result); } template void __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator2 __result, _Distance __step_size, _Compare __comp) { const _Distance __two_step = 2 * __step_size; while (__last - __first >= __two_step) { __result = std::merge(__first, __first + __step_size, __first + __step_size, __first + __two_step, __result, __comp); __first += __two_step; } __step_size = std::min(_Distance(__last - __first), __step_size); std::merge(__first, __first + __step_size, __first + __step_size, __last, __result, __comp); } enum { _S_chunk_size = 7 }; template void __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance __chunk_size) { while (__last - __first >= __chunk_size) { std::__insertion_sort(__first, __first + __chunk_size); __first += __chunk_size; } std::__insertion_sort(__first, __last); } template void __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance __chunk_size, _Compare __comp) { while (__last - __first >= __chunk_size) { std::__insertion_sort(__first, __first + __chunk_size, __comp); __first += __chunk_size; } std::__insertion_sort(__first, __last, __comp); } template void __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer) { typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; const _Distance __len = __last - __first; const _Pointer __buffer_last = __buffer + __len; _Distance __step_size = _S_chunk_size; std::__chunk_insertion_sort(__first, __last, __step_size); while (__step_size < __len) { std::__merge_sort_loop(__first, __last, __buffer, __step_size); __step_size *= 2; std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size); __step_size *= 2; } } template void __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; const _Distance __len = __last - __first; const _Pointer __buffer_last = __buffer + __len; _Distance __step_size = _S_chunk_size; std::__chunk_insertion_sort(__first, __last, __step_size, __comp); while (__step_size < __len) { std::__merge_sort_loop(__first, __last, __buffer, __step_size, __comp); __step_size *= 2; std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp); __step_size *= 2; } } template _BidirectionalIterator3 __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BidirectionalIterator3 __result) { if (__first1 == __last1) return std::copy_backward(__first2, __last2, __result); if (__first2 == __last2) return std::copy_backward(__first1, __last1, __result); --__last1; --__last2; while (true) { if (*__last2 < *__last1) { *--__result = *__last1; if (__first1 == __last1) return std::copy_backward(__first2, ++__last2, __result); --__last1; } else { *--__result = *__last2; if (__first2 == __last2) return std::copy_backward(__first1, ++__last1, __result); --__last2; } } } template _BidirectionalIterator3 __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BidirectionalIterator3 __result, _Compare __comp) { if (__first1 == __last1) return std::copy_backward(__first2, __last2, __result); if (__first2 == __last2) return std::copy_backward(__first1, __last1, __result); --__last1; --__last2; while (true) { if (__comp(*__last2, *__last1)) { *--__result = *__last1; if (__first1 == __last1) return std::copy_backward(__first2, ++__last2, __result); --__last1; } else { *--__result = *__last2; if (__first2 == __last2) return std::copy_backward(__first1, ++__last1, __result); --__last2; } } } template _BidirectionalIterator1 __rotate_adaptive(_BidirectionalIterator1 __first, _BidirectionalIterator1 __middle, _BidirectionalIterator1 __last, _Distance __len1, _Distance __len2, _BidirectionalIterator2 __buffer, _Distance __buffer_size) { _BidirectionalIterator2 __buffer_end; if (__len1 > __len2 && __len2 <= __buffer_size) { __buffer_end = std::copy(__middle, __last, __buffer); std::copy_backward(__first, __middle, __last); return std::copy(__buffer, __buffer_end, __first); } else if (__len1 <= __buffer_size) { __buffer_end = std::copy(__first, __middle, __buffer); std::copy(__middle, __last, __first); return std::copy_backward(__buffer, __buffer_end, __last); } else { std::rotate(__first, __middle, __last); std::advance(__first, std::distance(__middle, __last)); return __first; } } template void __merge_adaptive(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Pointer __buffer, _Distance __buffer_size) { if (__len1 <= __len2 && __len1 <= __buffer_size) { _Pointer __buffer_end = std::copy(__first, __middle, __buffer); std::merge(__buffer, __buffer_end, __middle, __last, __first); } else if (__len2 <= __buffer_size) { _Pointer __buffer_end = std::copy(__middle, __last, __buffer); std::__merge_backward(__first, __middle, __buffer, __buffer_end, __last); } else { _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::lower_bound(__middle, __last, *__first_cut); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::upper_bound(__first, __middle, *__second_cut); __len11 = std::distance(__first, __first_cut); } _BidirectionalIterator __new_middle = std::__rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11, __len22, __buffer, __buffer_size); std::__merge_adaptive(__first, __first_cut, __new_middle, __len11, __len22, __buffer, __buffer_size); std::__merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11, __len2 - __len22, __buffer, __buffer_size); } } template void __merge_adaptive(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Pointer __buffer, _Distance __buffer_size, _Compare __comp) { if (__len1 <= __len2 && __len1 <= __buffer_size) { _Pointer __buffer_end = std::copy(__first, __middle, __buffer); std::merge(__buffer, __buffer_end, __middle, __last, __first, __comp); } else if (__len2 <= __buffer_size) { _Pointer __buffer_end = std::copy(__middle, __last, __buffer); std::__merge_backward(__first, __middle, __buffer, __buffer_end, __last, __comp); } else { _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::lower_bound(__middle, __last, *__first_cut, __comp); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::upper_bound(__first, __middle, *__second_cut, __comp); __len11 = std::distance(__first, __first_cut); } _BidirectionalIterator __new_middle = std::__rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11, __len22, __buffer, __buffer_size); std::__merge_adaptive(__first, __first_cut, __new_middle, __len11, __len22, __buffer, __buffer_size, __comp); std::__merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11, __len2 - __len22, __buffer, __buffer_size, __comp); } } template void inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) { typedef typename iterator_traits<_BidirectionalIterator>::value_type _ValueType; typedef typename iterator_traits<_BidirectionalIterator>::difference_type _DistanceType; ; ; if (__first == __middle || __middle == __last) return; _DistanceType __len1 = std::distance(__first, __middle); _DistanceType __len2 = std::distance(__middle, __last); _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last); if (__buf.begin() == 0) std::__merge_without_buffer(__first, __middle, __last, __len1, __len2); else std::__merge_adaptive(__first, __middle, __last, __len1, __len2, __buf.begin(), _DistanceType(__buf.size())); } template void inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) { typedef typename iterator_traits<_BidirectionalIterator>::value_type _ValueType; typedef typename iterator_traits<_BidirectionalIterator>::difference_type _DistanceType; ; ; if (__first == __middle || __middle == __last) return; const _DistanceType __len1 = std::distance(__first, __middle); const _DistanceType __len2 = std::distance(__middle, __last); _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last); if (__buf.begin() == 0) std::__merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp); else std::__merge_adaptive(__first, __middle, __last, __len1, __len2, __buf.begin(), _DistanceType(__buf.size()), __comp); } template void __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Distance __buffer_size) { const _Distance __len = (__last - __first + 1) / 2; const _RandomAccessIterator __middle = __first + __len; if (__len > __buffer_size) { std::__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size); std::__stable_sort_adaptive(__middle, __last, __buffer, __buffer_size); } else { std::__merge_sort_with_buffer(__first, __middle, __buffer); std::__merge_sort_with_buffer(__middle, __last, __buffer); } std::__merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), _Distance(__last - __middle), __buffer, __buffer_size); } template void __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Distance __buffer_size, _Compare __comp) { const _Distance __len = (__last - __first + 1) / 2; const _RandomAccessIterator __middle = __first + __len; if (__len > __buffer_size) { std::__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size, __comp); std::__stable_sort_adaptive(__middle, __last, __buffer, __buffer_size, __comp); } else { std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp); std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp); } std::__merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), _Distance(__last - __middle), __buffer, __buffer_size, __comp); } template inline void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last); if (buf.begin() == 0) std::__inplace_stable_sort(__first, __last); else std::__stable_sort_adaptive(__first, __last, buf.begin(), _DistanceType(buf.size())); } template inline void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; ; _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last); if (buf.begin() == 0) std::__inplace_stable_sort(__first, __last, __comp); else std::__stable_sort_adaptive(__first, __last, buf.begin(), _DistanceType(buf.size()), __comp); } template void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; ; ; while (__last - __first > 3) { _RandomAccessIterator __cut = std::__unguarded_partition(__first, __last, _ValueType(std::__median(*__first, *(__first + (__last - __first) / 2), *(__last - 1)))); if (__cut <= __nth) __first = __cut; else __last = __cut; } std::__insertion_sort(__first, __last); } template void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; ; ; while (__last - __first > 3) { _RandomAccessIterator __cut = std::__unguarded_partition(__first, __last, _ValueType(std::__median(*__first, *(__first + (__last - __first) / 2), *(__last - 1), __comp)), __comp); if (__cut <= __nth) __first = __cut; else __last = __cut; } std::__insertion_sort(__first, __last, __comp); } template pair<_ForwardIterator, _ForwardIterator> equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; ; _DistanceType __len = std::distance(__first, __last); _DistanceType __half; _ForwardIterator __middle, __left, __right; while (__len > 0) { __half = __len >> 1; __middle = __first; std::advance(__middle, __half); if (*__middle < __val) { __first = __middle; ++__first; __len = __len - __half - 1; } else if (__val < *__middle) __len = __half; else { __left = std::lower_bound(__first, __middle, __val); std::advance(__first, __len); __right = std::upper_bound(++__middle, __first, __val); return pair<_ForwardIterator, _ForwardIterator>(__left, __right); } } return pair<_ForwardIterator, _ForwardIterator>(__first, __first); } template pair<_ForwardIterator, _ForwardIterator> equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; ; _DistanceType __len = std::distance(__first, __last); _DistanceType __half; _ForwardIterator __middle, __left, __right; while (__len > 0) { __half = __len >> 1; __middle = __first; std::advance(__middle, __half); if (__comp(*__middle, __val)) { __first = __middle; ++__first; __len = __len - __half - 1; } else if (__comp(__val, *__middle)) __len = __half; else { __left = std::lower_bound(__first, __middle, __val, __comp); std::advance(__first, __len); __right = std::upper_bound(++__middle, __first, __val, __comp); return pair<_ForwardIterator, _ForwardIterator>(__left, __right); } } return pair<_ForwardIterator, _ForwardIterator>(__first, __first); } template bool binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) { ; _ForwardIterator __i = std::lower_bound(__first, __last, __val); return __i != __last && !(__val < *__i); } template bool binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { ; _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp); return __i != __last && !__comp(__val, *__i); } template bool includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { ; ; while (__first1 != __last1 && __first2 != __last2) if (*__first2 < *__first1) return false; else if(*__first1 < *__first2) ++__first1; else ++__first1, ++__first2; return __first2 == __last2; } template bool includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __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 _OutputIterator set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __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 std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } template _OutputIterator set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __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 std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } template _OutputIterator set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; while (__first1 != __last1 && __first2 != __last2) if (*__first1 < *__first2) ++__first1; else if (*__first2 < *__first1) ++__first2; else { *__result = *__first1; ++__first1; ++__first2; ++__result; } return __result; } template _OutputIterator set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __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 _OutputIterator set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; while (__first1 != __last1 && __first2 != __last2) if (*__first1 < *__first2) { *__result = *__first1; ++__first1; ++__result; } else if (*__first2 < *__first1) ++__first2; else { ++__first1; ++__first2; } return std::copy(__first1, __last1, __result); } template _OutputIterator set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __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 std::copy(__first1, __last1, __result); } template _OutputIterator set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __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 std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } template _OutputIterator set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __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 std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } template _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last) { ; if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (*__result < *__first) __result = __first; return __result; } template _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (__comp(*__result, *__first)) __result = __first; return __result; } template _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last) { ; if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (*__first < *__result) __result = __first; return __result; } template _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (__comp(*__first, *__result)) __result = __first; return __result; } template bool next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (*__i < *__ii) { _BidirectionalIterator __j = __last; while (!(*__i < *--__j)) {} std::iter_swap(__i, __j); std::reverse(__ii, __last); return true; } if (__i == __first) { std::reverse(__first, __last); return false; } } } template bool next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { ; if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (__comp(*__i, *__ii)) { _BidirectionalIterator __j = __last; while (!__comp(*__i, *--__j)) {} std::iter_swap(__i, __j); std::reverse(__ii, __last); return true; } if (__i == __first) { std::reverse(__first, __last); return false; } } } template bool prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (*__ii < *__i) { _BidirectionalIterator __j = __last; while (!(*--__j < *__i)) {} std::iter_swap(__i, __j); std::reverse(__ii, __last); return true; } if (__i == __first) { std::reverse(__first, __last); return false; } } } template bool prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { ; if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (__comp(*__ii, *__i)) { _BidirectionalIterator __j = __last; while (!__comp(*--__j, *__i)) {} std::iter_swap(__i, __j); std::reverse(__ii, __last); return true; } if (__i == __first) { std::reverse(__first, __last); return false; } } } template _InputIterator find_first_of(_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2) { ; ; for ( ; __first1 != __last1; ++__first1) for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) if (*__first1 == *__iter) return __first1; return __last1; } template _InputIterator find_first_of(_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, _BinaryPredicate __comp) { ; ; for ( ; __first1 != __last1; ++__first1) for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) if (__comp(*__first1, *__iter)) return __first1; return __last1; } template _ForwardIterator1 __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, forward_iterator_tag, forward_iterator_tag) { if (__first2 == __last2) return __last1; else { _ForwardIterator1 __result = __last1; while (1) { _ForwardIterator1 __new_result = std::search(__first1, __last1, __first2, __last2); if (__new_result == __last1) return __result; else { __result = __new_result; __first1 = __new_result; ++__first1; } } } } template _ForwardIterator1 __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, forward_iterator_tag, forward_iterator_tag, _BinaryPredicate __comp) { if (__first2 == __last2) return __last1; else { _ForwardIterator1 __result = __last1; while (1) { _ForwardIterator1 __new_result = std::search(__first1, __last1, __first2, __last2, __comp); if (__new_result == __last1) return __result; else { __result = __new_result; __first1 = __new_result; ++__first1; } } } } template _BidirectionalIterator1 __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, bidirectional_iterator_tag, bidirectional_iterator_tag) { typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1; typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2; _RevIterator1 __rlast1(__first1); _RevIterator2 __rlast2(__first2); _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1, _RevIterator2(__last2), __rlast2); if (__rresult == __rlast1) return __last1; else { _BidirectionalIterator1 __result = __rresult.base(); std::advance(__result, -std::distance(__first2, __last2)); return __result; } } template _BidirectionalIterator1 __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, bidirectional_iterator_tag, bidirectional_iterator_tag, _BinaryPredicate __comp) { typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1; typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2; _RevIterator1 __rlast1(__first1); _RevIterator2 __rlast2(__first2); _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1, _RevIterator2(__last2), __rlast2, __comp); if (__rresult == __rlast1) return __last1; else { _BidirectionalIterator1 __result = __rresult.base(); std::advance(__result, -std::distance(__first2, __last2)); return __result; } } template inline _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { ; ; return std::__find_end(__first1, __last1, __first2, __last2, std::__iterator_category(__first1), std::__iterator_category(__first2)); } template inline _ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __comp) { ; ; return std::__find_end(__first1, __last1, __first2, __last2, std::__iterator_category(__first1), std::__iterator_category(__first2), __comp); } } namespace std { template inline bool __is_null_pointer(_Type* __ptr) { return __ptr == 0; } template inline bool __is_null_pointer(_Type) { return false; } template const typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4; template const _CharT basic_string<_CharT, _Traits, _Alloc>:: _Rep::_S_terminal = _CharT(); template const typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>::npos; template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[ (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) / sizeof(size_type)]; template template _CharT* basic_string<_CharT, _Traits, _Alloc>:: _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, input_iterator_tag) { if (__beg == __end && __a == _Alloc()) return _S_empty_rep()._M_refdata(); _CharT __buf[128]; size_type __len = 0; while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT)) { __buf[__len++] = *__beg; ++__beg; } _Rep* __r = _Rep::_S_create(__len, size_type(0), __a); _M_copy(__r->_M_refdata(), __buf, __len); try { while (__beg != __end) { if (__len == __r->_M_capacity) { _Rep* __another = _Rep::_S_create(__len + 1, __len, __a); _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len); __r->_M_destroy(__a); __r = __another; } __r->_M_refdata()[__len++] = *__beg; ++__beg; } } catch(...) { __r->_M_destroy(__a); throw; } __r->_M_set_length_and_sharable(__len); return __r->_M_refdata(); } template template _CharT* basic_string<_CharT, _Traits, _Alloc>:: _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, forward_iterator_tag) { if (__beg == __end && __a == _Alloc()) return _S_empty_rep()._M_refdata(); if (__builtin_expect(__is_null_pointer(__beg) && __beg != __end, 0)) __throw_logic_error(("basic_string::_S_construct NULL not valid")); const size_type __dnew = static_cast(std::distance(__beg, __end)); _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a); try { _S_copy_chars(__r->_M_refdata(), __beg, __end); } catch(...) { __r->_M_destroy(__a); throw; } __r->_M_set_length_and_sharable(__dnew); return __r->_M_refdata(); } template _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_refdata(); _Rep* __r = _Rep::_S_create(__n, size_type(0), __a); if (__n) _M_assign(__r->_M_refdata(), __n, __c); __r->_M_set_length_and_sharable(__n); return __r->_M_refdata(); } template 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()), __str.get_allocator()) { } template basic_string<_CharT, _Traits, _Alloc>:: basic_string(const _Alloc& __a) : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a) { } template basic_string<_CharT, _Traits, _Alloc>:: basic_string(const basic_string& __str, size_type __pos, size_type __n) : _M_dataplus(_S_construct(__str._M_data() + __str._M_check(__pos, "basic_string::basic_string"), __str._M_data() + __str._M_limit(__pos, __n) + __pos, _Alloc()), _Alloc()) { } template 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_data() + __str._M_check(__pos, "basic_string::basic_string"), __str._M_data() + __str._M_limit(__pos, __n) + __pos, __a), __a) { } template 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 basic_string<_CharT, _Traits, _Alloc>:: basic_string(const _CharT* __s, const _Alloc& __a) : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) : __s + npos, __a), __a) { } template basic_string<_CharT, _Traits, _Alloc>:: basic_string(size_type __n, _CharT __c, const _Alloc& __a) : _M_dataplus(_S_construct(__n, __c, __a), __a) { } template template basic_string<_CharT, _Traits, _Alloc>:: basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a) : _M_dataplus(_S_construct(__beg, __end, __a), __a) { } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: assign(const basic_string& __str) { if (_M_rep() != __str._M_rep()) { const 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 basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: assign(const _CharT* __s, size_type __n) { ; _M_check_length(this->size(), __n, "basic_string::assign"); if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) return _M_replace_safe(size_type(0), this->size(), __s, __n); else { const size_type __pos = __s - _M_data(); if (__pos >= __n) _M_copy(_M_data(), __s, __n); else if (__pos) _M_move(_M_data(), __s, __n); _M_rep()->_M_set_length_and_sharable(__n); return *this; } } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: append(size_type __n, _CharT __c) { if (__n) { _M_check_length(size_type(0), __n, "basic_string::append"); const size_type __len = __n + this->size(); if (__len > this->capacity() || _M_rep()->_M_is_shared()) this->reserve(__len); _M_assign(_M_data() + this->size(), __n, __c); _M_rep()->_M_set_length_and_sharable(__len); } return *this; } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: append(const _CharT* __s, size_type __n) { ; if (__n) { _M_check_length(size_type(0), __n, "basic_string::append"); const size_type __len = __n + this->size(); if (__len > this->capacity() || _M_rep()->_M_is_shared()) { if (_M_disjunct(__s)) this->reserve(__len); else { const size_type __off = __s - _M_data(); this->reserve(__len); __s = _M_data() + __off; } } _M_copy(_M_data() + this->size(), __s, __n); _M_rep()->_M_set_length_and_sharable(__len); } return *this; } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: append(const basic_string& __str) { const size_type __size = __str.size(); if (__size) { const size_type __len = __size + this->size(); if (__len > this->capacity() || _M_rep()->_M_is_shared()) this->reserve(__len); _M_copy(_M_data() + this->size(), __str._M_data(), __size); _M_rep()->_M_set_length_and_sharable(__len); } return *this; } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: append(const basic_string& __str, size_type __pos, size_type __n) { __str._M_check(__pos, "basic_string::append"); __n = __str._M_limit(__pos, __n); if (__n) { const size_type __len = __n + this->size(); if (__len > this->capacity() || _M_rep()->_M_is_shared()) this->reserve(__len); _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n); _M_rep()->_M_set_length_and_sharable(__len); } return *this; } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: insert(size_type __pos, const _CharT* __s, size_type __n) { ; _M_check(__pos, "basic_string::insert"); _M_check_length(size_type(0), __n, "basic_string::insert"); if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) return _M_replace_safe(__pos, size_type(0), __s, __n); else { const size_type __off = __s - _M_data(); _M_mutate(__pos, 0, __n); __s = _M_data() + __off; _CharT* __p = _M_data() + __pos; if (__s + __n <= __p) _M_copy(__p, __s, __n); else if (__s >= __p) _M_copy(__p, __s + __n, __n); else { const size_type __nleft = __p - __s; _M_copy(__p, __s, __nleft); _M_copy(__p + __nleft, __p + __n, __n - __nleft); } return *this; } } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) { ; _M_check(__pos, "basic_string::replace"); __n1 = _M_limit(__pos, __n1); _M_check_length(__n1, __n2, "basic_string::replace"); bool __left; if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) return _M_replace_safe(__pos, __n1, __s, __n2); else if ((__left = __s + __n2 <= _M_data() + __pos) || _M_data() + __pos + __n1 <= __s) { size_type __off = __s - _M_data(); __left ? __off : (__off += __n2 - __n1); _M_mutate(__pos, __n1, __n2); _M_copy(_M_data() + __pos, _M_data() + __off, __n2); return *this; } else { const basic_string __tmp(__s, __n2); return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2); } } template void basic_string<_CharT, _Traits, _Alloc>::_Rep:: _M_destroy(const _Alloc& __a) throw () { const size_type __size = sizeof(_Rep_base) + (this->_M_capacity + 1) * sizeof(_CharT); _Raw_bytes_alloc(__a).deallocate(reinterpret_cast(this), __size); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_leak_hard() { if (_M_rep() == &_S_empty_rep()) return; if (_M_rep()->_M_is_shared()) _M_mutate(0, 0, 0); _M_rep()->_M_set_leaked(); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_mutate(size_type __pos, size_type __len1, size_type __len2) { const size_type __old_size = this->size(); const size_type __new_size = __old_size + __len2 - __len1; const size_type __how_much = __old_size - __pos - __len1; if (__new_size > this->capacity() || _M_rep()->_M_is_shared()) { const allocator_type __a = get_allocator(); _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a); if (__pos) _M_copy(__r->_M_refdata(), _M_data(), __pos); if (__how_much) _M_copy(__r->_M_refdata() + __pos + __len2, _M_data() + __pos + __len1, __how_much); _M_rep()->_M_dispose(__a); _M_data(__r->_M_refdata()); } else if (__how_much && __len1 != __len2) { _M_move(_M_data() + __pos + __len2, _M_data() + __pos + __len1, __how_much); } _M_rep()->_M_set_length_and_sharable(__new_size); } template void basic_string<_CharT, _Traits, _Alloc>:: reserve(size_type __res) { if (__res != this->capacity() || _M_rep()->_M_is_shared()) { if (__res < this->size()) __res = this->size(); const allocator_type __a = get_allocator(); _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size()); _M_rep()->_M_dispose(__a); _M_data(__tmp); } } template 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 { const basic_string __tmp1(_M_ibegin(), _M_iend(), __s.get_allocator()); const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(), this->get_allocator()); *this = __tmp2; __s = __tmp1; } } template typename basic_string<_CharT, _Traits, _Alloc>::_Rep* basic_string<_CharT, _Traits, _Alloc>::_Rep:: _S_create(size_type __capacity, size_type __old_capacity, const _Alloc& __alloc) { if (__capacity > _S_max_size) __throw_length_error(("basic_string::_S_create")); const size_type __pagesize = 4096; const size_type __malloc_header_size = 4 * sizeof(void*); if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) __capacity = 2 * __old_capacity; size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); const size_type __adj_size = __size + __malloc_header_size; if (__adj_size > __pagesize && __capacity > __old_capacity) { const size_type __extra = __pagesize - __adj_size % __pagesize; __capacity += __extra / sizeof(_CharT); if (__capacity > _S_max_size) __capacity = _S_max_size; __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); } void* __place = _Raw_bytes_alloc(__alloc).allocate(__size); _Rep *__p = new (__place) _Rep; __p->_M_capacity = __capacity; return __p; } template _CharT* basic_string<_CharT, _Traits, _Alloc>::_Rep:: _M_clone(const _Alloc& __alloc, size_type __res) { const size_type __requested_cap = this->_M_length + __res; _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity, __alloc); if (this->_M_length) _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length); __r->_M_set_length_and_sharable(this->_M_length); return __r->_M_refdata(); } template void basic_string<_CharT, _Traits, _Alloc>:: resize(size_type __n, _CharT __c) { const size_type __size = this->size(); _M_check_length(__size, __n, "basic_string::resize"); if (__size < __n) this->append(__n - __size, __c); else if (__n < __size) this->erase(__n); } template template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, _InputIterator __k2, __false_type) { const basic_string __s(__k1, __k2); const size_type __n1 = __i2 - __i1; _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch"); return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(), __s.size()); } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, _CharT __c) { _M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); _M_mutate(__pos1, __n1, __n2); if (__n2) _M_assign(_M_data() + __pos1, __n2, __c); return *this; } template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) { _M_mutate(__pos1, __n1, __n2); if (__n2) _M_copy(_M_data() + __pos1, __s, __n2); return *this; } template 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; const __size_type __len = _Traits::length(__lhs); __string_type __str; __str.reserve(__len + __rhs.size()); __str.append(__lhs, __len); __str.append(__rhs); return __str; } template 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; const __size_type __len = __rhs.size(); __str.reserve(__len + 1); __str.append(__size_type(1), __lhs); __str.append(__rhs); return __str; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: copy(_CharT* __s, size_type __n, size_type __pos) const { _M_check(__pos, "basic_string::copy"); __n = _M_limit(__pos, __n); ; if (__n) _M_copy(__s, _M_data() + __pos, __n); return __n; } template 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 __ret = npos; const size_type __size = this->size(); if (__pos + __n <= __size) { const _CharT* __data = _M_data(); const _CharT* __p = std::search(__data + __pos, __data + __size, __s, __s + __n, traits_type::eq); if (__p != __data + __size || __n == 0) __ret = __p - __data; } return __ret; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find(_CharT __c, size_type __pos) const { size_type __ret = npos; const size_type __size = this->size(); if (__pos < __size) { const _CharT* __data = _M_data(); const size_type __n = __size - __pos; const _CharT* __p = traits_type::find(__data + __pos, __n, __c); if (__p) __ret = __p - __data; } return __ret; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: rfind(const _CharT* __s, size_type __pos, size_type __n) const { ; const size_type __size = this->size(); if (__n <= __size) { __pos = std::min(size_type(__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 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) { if (--__size > __pos) __size = __pos; for (++__size; __size-- > 0; ) if (traits_type::eq(_M_data()[__size], __c)) return __size; } return npos; } template 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 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 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 { ; for (; __pos < this->size(); ++__pos) if (!traits_type::find(__s, __n, _M_data()[__pos])) return __pos; return npos; } template typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_first_not_of(_CharT __c, size_type __pos) const { for (; __pos < this->size(); ++__pos) if (!traits_type::eq(_M_data()[__pos], __c)) return __pos; return npos; } template 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) { if (--__size > __pos) __size = __pos; do { if (!traits_type::find(__s, __n, _M_data()[__size])) return __size; } while (__size--); } return npos; } template 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 int basic_string<_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n, const basic_string& __str) const { _M_check(__pos, "basic_string::compare"); __n = _M_limit(__pos, __n); const size_type __osize = __str.size(); const size_type __len = std::min(__n, __osize); int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); if (!__r) __r = __n - __osize; return __r; } template int basic_string<_CharT, _Traits, _Alloc>:: compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) const { _M_check(__pos1, "basic_string::compare"); __str._M_check(__pos2, "basic_string::compare"); __n1 = _M_limit(__pos1, __n1); __n2 = __str._M_limit(__pos2, __n2); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos1, __str.data() + __pos2, __len); if (!__r) __r = __n1 - __n2; return __r; } template int basic_string<_CharT, _Traits, _Alloc>:: compare(const _CharT* __s) const { ; const size_type __size = this->size(); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __s, __len); if (!__r) __r = __size - __osize; return __r; } template int basic_string <_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n1, const _CharT* __s) const { ; _M_check(__pos, "basic_string::compare"); __n1 = _M_limit(__pos, __n1); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__n1, __osize); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = __n1 - __osize; return __r; } template int basic_string <_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) const { ; _M_check(__pos, "basic_string::compare"); __n1 = _M_limit(__pos, __n1); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = __n1 - __n2; return __r; } extern template class basic_string; extern template basic_istream& operator>>(basic_istream&, string&); extern template basic_ostream& operator<<(basic_ostream&, const string&); extern template basic_istream& getline(basic_istream&, string&, char); extern template basic_istream& getline(basic_istream&, string&); } namespace Pl { enum Exit_Status_t { Exit_NORMAL = 0, Exit_FATAL = 1 }; namespace Constraint_Error { } namespace Program_Error { } template class No_Such_t { public: No_Such_t () {} }; template class Is_Predefined_t { public: typedef int No; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template <> class Is_Predefined_t { public: typedef int Yes; }; template class Is_Integer_t { public: typedef int No; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template <> class Is_Integer_t { public: typedef int Yes; }; template class Is_Float_t { public: typedef int No; }; template <> class Is_Float_t { public: typedef int Yes; }; template <> class Is_Float_t { public: typedef int Yes; }; template <> class Is_Float_t { public: typedef int Yes; }; template class Is_Numeric_t { public: typedef int No; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef char t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef signed char t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef unsigned char t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef signed short t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef unsigned short t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef signed int t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef unsigned int t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef signed long t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef unsigned long t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef float t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef double t; }; template <> class Is_Numeric_t { public: typedef int Yes; typedef long double t; }; template class Is_Scalar_t { public: typedef int No; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef char Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef signed char Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef unsigned char Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef signed short Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef unsigned short Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef signed int Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef unsigned int Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef signed long Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef unsigned long Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef float Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef double Raw_t; }; template <> class Is_Scalar_t { public: typedef int Yes; typedef long double Raw_t; }; template class Is_Char_t { public: typedef int No; }; template <> class Is_Char_t { public: typedef int Yes; }; template <> class Is_Char_t { public: typedef int Yes; }; template <> class Is_Char_t { public: typedef int Yes; }; template class Is_Void_t { public: typedef int No; }; template <> class Is_Void_t { public: typedef int Yes; }; template class Is_Bool_t { public: typedef int No; }; template <> class Is_Bool_t { public: typedef int Yes; }; template class Is_Signed_t { public: typedef int No; }; template <> class Is_Signed_t { public: typedef int Yes; }; template <> class Is_Signed_t { public: typedef int Yes; }; template <> class Is_Signed_t { public: typedef int Yes; }; template <> class Is_Signed_t { public: typedef int Yes; }; template <> class Is_Signed_t { public: typedef int Yes; }; template <> class Is_Signed_t { public: typedef int Yes; }; template <> class Is_Signed_t { public: typedef int Yes; }; template <> class Is_Signed_t { public: typedef int Yes; }; template class Is_Unsigned_t { public: typedef int No; }; template <> class Is_Unsigned_t { public: typedef int Yes; }; template <> class Is_Unsigned_t { public: typedef int Yes; }; template <> class Is_Unsigned_t { public: typedef int Yes; }; template <> class Is_Unsigned_t { public: typedef int Yes; }; template class For_Array_Index_t { public: typedef Pl::S_Addr_t No; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template <> class For_Array_Index_t { public: typedef Pl::S_Addr_t Yes; }; template inline typename For_Array_Index_t <_T>::Yes Use_Numeric_For_Array_Index (const _T &__x) { return static_cast ::Yes> (__x); } template inline typename _T::For_Array_Index_t Use_Numeric_For_Array_Index (const _T &__x) { return static_cast (__x.Raw ()); } } namespace Pl { namespace Safe { template class Pointer_To; template > class Integer; } extern const Char_t U_Address_t_Print_Name []; extern const Char_t S_Address_t_Print_Name []; extern const Char_t U_Address_p_Print_Name []; extern const Char_t S_Address_p_Print_Name []; extern const Char_t Storage_Unit_t_Print_Name []; extern const Char_t Storage_Unit_p_Print_Name []; typedef Safe::Integer U_Address_t; typedef Safe::Integer S_Address_t; typedef Safe::Pointer_To U_Address_p; typedef Safe::Pointer_To S_Address_p; typedef Safe::Integer Storage_Unit_t; typedef Safe::Pointer_To Storage_Unit_p; typedef Safe::Pointer_To const_Storage_Unit_p; extern const Char_t S_Char_t_Print_Name []; extern const Char_t S_Short_t_Print_Name []; extern const Char_t S_Long_t_Print_Name []; extern const Char_t S_Int_t_Print_Name []; extern const Char_t U_Char_t_Print_Name []; extern const Char_t U_Short_t_Print_Name []; extern const Char_t U_Long_t_Print_Name []; extern const Char_t U_Int_t_Print_Name []; extern const Char_t U_Pointer_Difference_t_Print_Name []; extern const Char_t S_Pointer_Difference_t_Print_Name []; extern const Char_t S_Size_Of_t_Print_Name []; extern const Char_t U_Size_Of_t_Print_Name []; typedef Safe::Integer S_Char_t; typedef Safe::Integer S_Short_t; typedef Safe::Integer S_Int_t; typedef Safe::Integer S_Long_t; typedef Safe::Integer U_Char_t; typedef Safe::Integer U_Short_t; typedef Safe::Integer U_Int_t; typedef Safe::Integer U_Long_t; typedef Safe::Integer U_Ptrdiff_t; typedef Safe::Integer S_Ptrdiff_t; typedef Safe::Integer U_Size_Of_t; typedef Safe::Integer S_Size_Of_t; struct Date_Time_t { std::time_t Date_Time; }; template inline typename Pl::Is_Numeric_t <_Numeric>::t abs (const typename Pl::Is_Numeric_t <_Numeric>::t &__x) { if (std::numeric_limits <_Numeric>::is_signed) { if (! (__x >= 0)) { return - __x; } } return __x; } class Run_On_Initialization { private: Run_On_Initialization () {} public: Run_On_Initialization (void (&Proc)()) { Proc (); } ~Run_On_Initialization () {} }; class Run_On_Finalization { private: Run_On_Finalization () : Run_Proc (0) {} void (*Run_Proc) (); public: Run_On_Finalization (void (*Proc)()) : Run_Proc (Proc) { } ~Run_On_Finalization () { Run_Proc (); } }; namespace State { extern void Initialize (); extern void Finalize (); static Pl::Run_On_Initialization Prolib_Initialized_Guarantee ( Pl::State::Initialize); static Pl::Run_On_Finalization Prolib_Finalized_Guarantee ( Pl::State::Finalize); } void debugstop (); template class Save_Restore_t { _Any_t & Savee; _Any_t Saved; public: Save_Restore_t (_Any_t & Save) : Savee (Save) , Saved (Save) {} Save_Restore_t (_Any_t & Save, const _Any_t & Initial) : Savee (Save) , Saved (Save) { Save = Initial; } ~Save_Restore_t () { Savee = Saved; } Save_Restore_t& operator= (const _Any_t& New_Value) { Saved = New_Value; } }; template inline bool Eliminate_Warning_Msg () { return Flag; } } namespace Pl { namespace Safe { template ::Yes Yes = 0> class Base_Variant_t { public: typedef typename Is_Scalar_t <_Discriminant_t>::Raw_t Raw_Discriminant_t; typedef _Discriminant_t Discriminant_t; typedef Pl::No_Such_t Contained_Class_t; typedef int Is_Variant_Container_t; class d { protected: Discriminant_t Discriminant; d () {} d (const Discriminant_t& Discr) : Discriminant (Discr) {} d& operator= (const d& Discr) { this->Discriminant = Discr.Discriminant; return *this; } bool operator== (const d& Discr) const { return this->Discriminant == Discr.Discriminant; } public: typedef int Is_Variant_Contained_t; const Discriminant_t& Variant () const { return Discriminant; } }; protected: class _No_Such_t { public: Pl::Char_t _No; }; union { _No_Such_t Discriminant; double __Trash; }; template friend class Final_Default_Variant_t; template friend class Final_No_Default_Variant_t; enum { Size_Of = (sizeof (Discriminant_t) > sizeof (8) ? sizeof (Discriminant_t) : sizeof (double)) }; Base_Variant_t () {} Base_Variant_t (const Discriminant_t& Discr) { *reinterpret_cast (&Discriminant) = Discr; } void Upward_Constructor (const Discriminant_t& ) { throw 1; } void Upward_Constructor (const Contained_Class_t& ) { throw 1; } bool Upward_Variant (No_Such_t ) { throw 1; } void Upward_Assignment (const Contained_Class_t& ) { throw 1; } void Variant (const Discriminant_t& Discr) { *reinterpret_cast (&Discriminant) = Discr; } void Upward_Destructor () { throw 1; } const Contained_Class_t& v () const { throw 1; } bool Same_Variant (const Discriminant_t& , const Discriminant_t& ) { return false; } public: static Pl::Const_Char_p Class_Print_Name () { return _Class_Print_Name; } const Discriminant_t& Variant () const { return *reinterpret_cast (&Discriminant); } }; }} namespace Pl { namespace Safe { namespace Private { template class Contained_Class_t : public _Base_Variant_t::d { public: Contained_Class_t () : _Base_Variant_t::d (_Discr) , Data () {} Contained_Class_t (const _Contained_Class_t& X) : _Base_Variant_t::d (_Discr) , Data (X) {} _Contained_Class_t Data; }; template class Is_Not_Variant_Contained_t { public: typedef int Yes; }; template class Is_Not_Variant_Contained_t < _Contained_Class_t, typename _Contained_Class_t::Is_Variant_Contained_t>{ public: typedef int No; }; }}} namespace Pl { namespace Safe { }} namespace Pl { namespace Safe { namespace Private { template class Single_Variant_t : public _Base_Variant_t { public: typedef typename _Base_Variant_t::Discriminant_t Discriminant_t; protected: Single_Variant_t () : _Base_Variant_t (_Discr) {} Single_Variant_t (const Discriminant_t& Discr) : _Base_Variant_t (Discr) { } void Upward_Constructor (const Discriminant_t& Discr) { if (Discr == _Discr) { new (reinterpret_cast <_Contained_Class_t*> (this)) _Contained_Class_t (); this->Variant (Discr); } else { _Base_Variant_t::Upward_Constructor (Discr); } } using _Base_Variant_t::Upward_Constructor; void Upward_Constructor (const _Contained_Class_t& Initial) { if (Initial.Variant () == _Discr) { new (reinterpret_cast <_Contained_Class_t*> (this)) _Contained_Class_t (Initial); this->v (); } else { _Base_Variant_t::Upward_Constructor ( *reinterpret_cast ( &Initial)); } } using _Base_Variant_t::Upward_Variant; bool Upward_Variant (const _Contained_Class_t& ) { return this->Variant () == _Discr; } void Upward_Destructor () { if (this->Variant () == _Discr) { this->v ().~_Contained_Class_t (); } else { _Base_Variant_t::Upward_Destructor (); } } using _Base_Variant_t::Upward_Assignment; void Upward_Assignment (const _Contained_Class_t& From) { if (this->Variant () == _Discr) { this->v () = From; } else { _Base_Variant_t::Upward_Assignment ( *reinterpret_cast ( &From) ); } } template friend class Final_Default_Variant_t; template friend class Final_No_Default_Variant_t; enum { Size_Of = (sizeof (_Contained_Class_t) > _Base_Variant_t::Size_Of ? sizeof (_Contained_Class_t) : static_cast (_Base_Variant_t::Size_Of)) }; public: _Contained_Class_t& v () { if (this->Variant () == _Discr) { return *reinterpret_cast <_Contained_Class_t*> (this); } else { throw 1; } } const _Contained_Class_t& v () const { if (this->Variant () == _Discr) { return *reinterpret_cast (this); } else { throw 1; } } }; }}} namespace Pl { namespace Safe { template class Single_Embedded_Variant_t : public Private::Single_Variant_t <_Base_Variant_t, _Contained_Class_t, _Discr> { public: typedef _Contained_Class_t Contained_Class_t; protected: typedef Private::Single_Variant_t <_Base_Variant_t, _Contained_Class_t, _Discr> Base_v; using Base_v::Upward_Assignment; using Base_v::Upward_Variant; Single_Embedded_Variant_t () : Base_v (_Discr) {} Single_Embedded_Variant_t ( const typename Base_v::Discriminant_t& Discr) : Base_v (Discr) { } template friend class Final_Default_Variant_t; template friend class Final_No_Default_Variant_t; public: Contained_Class_t& v () { if (this->Variant () == _Discr) { return *reinterpret_cast (this); } else { throw 1; } } const Contained_Class_t& v () const { if (this->Variant () == _Discr) { return *reinterpret_cast (this); } else { throw 1; } } }; template > class Single_Separate_Variant_t : public Private::Single_Variant_t <_Base_Variant_t, Private::Contained_Class_t < _Base_Variant_t, _Contained_Class_t, _Discr>, _Discr> { public: typedef typename _Base_Variant_t::Discriminant_t Discriminant_t; typedef typename _Base_Variant_t::Raw_Discriminant_t Raw_Discriminant_t; typedef typename _Base_Variant_t::Is_Variant_Container_t Is_Variant_Container_t; typedef Private::Contained_Class_t <_Base_Variant_t, _Contained_Class_t, _Discr> Contained_Class_t; protected: typedef Private::Single_Variant_t <_Base_Variant_t, Contained_Class_t, _Discr> Base_v; Single_Separate_Variant_t () : Base_v (_Discr) {} Single_Separate_Variant_t ( const typename Base_v::Discriminant_t& Discr) : Base_v (Discr) { } using Base_v::Upward_Variant; bool Upward_Variant (const _Contained_Class_t& ) { return this->Variant () == _Discr; } using _Base_Variant_t::Upward_Assignment; void Upward_Assignment (const Contained_Class_t& From) { Base_v::Upward_Assignment (From); } void Upward_Assignment (const _Contained_Class_t& From) { this->v () = From; } template friend class Final_Default_Variant_t; template friend class Final_No_Default_Variant_t; public: _Contained_Class_t& v () { if (this->Variant () == _Discr) { return reinterpret_cast (this)->Data; } else { throw 1; } } const _Contained_Class_t& v () const { if (this->Variant () == _Discr) { return reinterpret_cast (this)->Data; } else { throw 1; } } }; }} namespace Pl { namespace Safe { namespace Private { template class Range_Variant_t : public _Base_Variant_t { public: typedef typename _Base_Variant_t::Discriminant_t Discriminant_t; protected: Range_Variant_t () : _Base_Variant_t (_First) {} Range_Variant_t (const Discriminant_t& Discr) : _Base_Variant_t (Discr) { } using _Base_Variant_t::Upward_Constructor; void Upward_Constructor (const Discriminant_t& Discr) { if (Discr >= _First && Discr <= _Last) { new (reinterpret_cast <_Contained_Class_t*> (this)) _Contained_Class_t (); this->Variant (Discr); } else { _Base_Variant_t::Upward_Constructor (Discr); } } void Upward_Constructor (const _Contained_Class_t& Initial) { if (Initial.Variant () >= _First && Initial.Variant () <= _Last) { new (reinterpret_cast <_Contained_Class_t*> (this)) _Contained_Class_t (Initial); this->v (); } else { _Base_Variant_t::Upward_Constructor ( *reinterpret_cast ( &Initial)); } } void Upward_Destructor () { if (this->Variant () >= _First && this->Variant () <= _Last) { this->v ().~_Contained_Class_t (); } else { _Base_Variant_t::Upward_Destructor (); } } bool Same_Variant (const Discriminant_t& Discr1, const Discriminant_t& Discr2) { if (Discr1 >= _First && Discr1 <= _Last && Discr2 >= _First && Discr2 <= _Last) { return true; } return _Base_Variant_t::Same_Variant (Discr1, Discr2); } using _Base_Variant_t::Upward_Assignment; void Upward_Assignment (const _Contained_Class_t& From) { if (this->Variant () >= _First && this->Variant () <= _Last) { this->v () = From; } else { _Base_Variant_t::Upward_Assignment ( *reinterpret_cast ( &From) ); } } template friend class Final_Default_Variant_t; template friend class Final_No_Default_Variant_t; enum { Size_Of = (sizeof (_Contained_Class_t) > _Base_Variant_t::Size_Of ? sizeof (_Contained_Class_t) : static_cast (_Base_Variant_t::Size_Of)) }; using _Base_Variant_t::Upward_Variant; bool Upward_Variant (const _Contained_Class_t& ) { return (this->Variant () >= _First && this->Variant () <= _Last); } public: _Contained_Class_t& v () { if (this->Variant () >= _First && this->Variant () <= _Last) { return *reinterpret_cast <_Contained_Class_t*> (this); } else { throw 1; } } const _Contained_Class_t& v () const { if (this->Variant () >= _First && this->Variant () <= _Last) { return *reinterpret_cast (this); } else { throw 1; } } }; }}} namespace Pl { namespace Safe { template class Range_Embedded_Variant_t : public Private::Range_Variant_t <_Base_Variant_t, _Contained_Class_t, _First, _Last> { public: typedef _Contained_Class_t Contained_Class_t; protected: typedef Private::Range_Variant_t <_Base_Variant_t, _Contained_Class_t, _First, _Last> Base_v; using Base_v::Upward_Assignment; using Base_v::Upward_Variant; Range_Embedded_Variant_t () : Base_v (_First) {} Range_Embedded_Variant_t (const typename Base_v::Discriminant_t& Discr) : Base_v (Discr) { } template friend class Final_Default_Variant_t; template friend class Final_No_Default_Variant_t; public: Contained_Class_t& v () { if (this->Variant () >= _First && this->Variant () <= _Last) { return *reinterpret_cast (this); } else { throw 1; } } const Contained_Class_t& v () const { if (this->Variant () >= _First && this->Variant () <= _Last) { return *reinterpret_cast (this); } else { throw 1; } } }; template class Range_Separate_Variant_t : public Private::Range_Variant_t <_Base_Variant_t, Private::Contained_Class_t < _Base_Variant_t, _Contained_Class_t, _First>, _First, _Last> { public: typedef typename _Base_Variant_t::Discriminant_t Discriminant_t; typedef typename _Base_Variant_t::Raw_Discriminant_t Raw_Discriminant_t; typedef typename _Base_Variant_t::Is_Variant_Container_t Is_Variant_Container_t; typedef Private::Contained_Class_t <_Base_Variant_t, _Contained_Class_t, _First> Contained_Class_t; protected: typedef Private::Range_Variant_t <_Base_Variant_t, Contained_Class_t, _First, _Last> Base_v; Range_Separate_Variant_t () : Base_v (_First) {} Range_Separate_Variant_t (const typename Base_v::Discriminant_t& Discr) : Base_v (Discr) { } using Base_v::Upward_Variant; bool Upward_Variant (const _Contained_Class_t& ) { return (this->Variant () >= _First && this->Variant () <= _Last); } using _Base_Variant_t::Upward_Assignment; void Upward_Assignment (const Contained_Class_t& From) { Base_v::Upward_Assignment (From); } void Upward_Assignment (const _Contained_Class_t& From) { this->v () = From; } template friend class Final_Default_Variant_t; template friend class Final_No_Default_Variant_t; public: _Contained_Class_t& v () { if (this->Variant () >= _First && this->Variant () <= _Last) { return reinterpret_cast (this)->Data; } else { throw 1; } } const _Contained_Class_t& v () const { if (this->Variant () >= _First && this->Variant () <= _Last) { return reinterpret_cast (this)->Data; } else { throw 1; } } }; template class Final_No_Default_Variant_t : public _Base_Variant_t { protected: typedef typename _Base_Variant_t::Contained_Class_t First_Contained_Class_t; public: typedef typename _Base_Variant_t::Discriminant_t Discriminant_t; typedef Pl::No_Such_t Is_Final_No_t; explicit Final_No_Default_Variant_t (const Discriminant_t& Discr) : _Base_Variant_t (Discr) { _Base_Variant_t::Upward_Constructor (Discr); } explicit Final_No_Default_Variant_t (const Final_No_Default_Variant_t& Value) : _Base_Variant_t (Value.Variant ()) { this->_Base_Variant_t::Upward_Constructor ( *reinterpret_cast (&Value)); } template explicit Final_No_Default_Variant_t ( const _Contained_Class_t& Value) { this->_Base_Variant_t::Upward_Constructor (Value); } ~Final_No_Default_Variant_t () { _Base_Variant_t::Upward_Destructor (); } using _Base_Variant_t::Variant; Final_No_Default_Variant_t& Variant (const Discriminant_t& Discr) { if (this->Variant () != Discr) { if (! _Base_Variant_t::Same_Variant (this->Variant (), Discr)) { _Base_Variant_t::Upward_Destructor (); _Base_Variant_t::Upward_Constructor (Discr); } else { this->Variant (Discr); } } return *this; } Final_No_Default_Variant_t& operator= (const Final_No_Default_Variant_t& Value) { if (this->Variant () != Value.Variant () && ! _Base_Variant_t::Same_Variant (this->Variant (), Value.Variant ())) { _Base_Variant_t::Upward_Destructor (); _Base_Variant_t::Upward_Constructor ( *reinterpret_cast ( &Value)); } else { Upward_Assignment ( *reinterpret_cast ( &Value)); } return *this; } template Final_No_Default_Variant_t& operator= (const _Contained_Class_t& Value) { if (! _Base_Variant_t::Upward_Variant (Value)) { _Base_Variant_t::Upward_Destructor (); _Base_Variant_t::Upward_Constructor (Value); } else { Upward_Assignment (Value); } return *this; } void v () const { } protected: enum { Size_Of = (sizeof (_Base_Variant_t) >= _Base_Variant_t::Size_Of ? 1 : _Base_Variant_t::Size_Of - sizeof (_Base_Variant_t)) }; char Filler [Size_Of]; }; template class Final_Default_Variant_t : public _Base_Variant_t { protected: typedef typename _Base_Variant_t::Contained_Class_t First_Contained_Class_t; public: typedef typename _Base_Variant_t::Discriminant_t Discriminant_t; typedef Pl::No_Such_t Is_Final_Def_t; explicit Final_Default_Variant_t (const Discriminant_t& Discr = Discriminant_t (_Default)) : _Base_Variant_t (Discr) { _Base_Variant_t::Upward_Constructor (Discr); } template explicit Final_Default_Variant_t (const _Contained_Class_t& Value) { this->_Base_Variant_t::Upward_Constructor (Value); } ~Final_Default_Variant_t () { _Base_Variant_t::Upward_Destructor (); } using _Base_Variant_t::Variant; Final_Default_Variant_t& Variant (const Discriminant_t& Discr) { if (this->Variant () != Discr) { if (! _Base_Variant_t::Same_Variant (this->Variant (), Discr)) { _Base_Variant_t::Upward_Destructor (); _Base_Variant_t::Upward_Constructor (Discr); } else { this->Variant (Discr); } } return *this; } Final_Default_Variant_t& operator= (const Final_Default_Variant_t& Value) { if (this->Variant () != Value.Variant () && ! _Base_Variant_t::Same_Variant (this->Variant (), Value.Variant ())) { _Base_Variant_t::Upward_Destructor (); _Base_Variant_t::Upward_Constructor ( *reinterpret_cast ( &Value)); } else { Upward_Assignment ( *reinterpret_cast ( &Value)); } return *this; } template Final_Default_Variant_t& operator= (const _Contained_Class_t& Value) { if (! _Base_Variant_t::Upward_Variant (Value)) { _Base_Variant_t::Upward_Destructor (); _Base_Variant_t::Upward_Constructor (Value); } else { Upward_Assignment (Value); } return *this; } void v () const { } protected: enum { Size_Of = (sizeof (_Base_Variant_t) >= _Base_Variant_t::Size_Of ? 1 : _Base_Variant_t::Size_Of - sizeof (_Base_Variant_t)) }; char Filler [Size_Of]; }; }} extern const char Base_v_Name [] = "Base_v"; typedef Pl::Safe::Base_Variant_t Base_v; class Variant1_t : public Base_v::d { public: Variant1_t () : Base_v::d (1) { std::cout << "construct Variant" "1" "_t" << std::endl; } Variant1_t (const Variant1_t& X) : Base_v::d (X) { std::cout << "construct Variant" "1" "_t(Initial)" << std::endl; *this = X; } }; typedef Pl::Safe::Single_Embedded_Variant_t Variant1_v; int real_main (int,char**) { return 0; }