Attachment 32979 Details for Bug 61571 – source file

source file

t.cpp (text/plain), 532.15 KB, created by davidxl on 2014-06-20 07:45:14 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: davidxl

Created: 2014-06-20 07:45:14 UTC

Size: 532.15 KB

patch

obsolete

>typedef int ptrdiff_t;
>typedef unsigned int size_t;
>typedef struct {
>  long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
>  long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
>} max_align_t;
>
>
>
>  typedef decltype(nullptr) nullptr_t;
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef short __int16_t;
>typedef unsigned short __uint16_t;
>typedef int __int32_t;
>typedef unsigned int __uint32_t;
>
>typedef long long __int64_t;
>
>typedef unsigned long long __uint64_t;
>
>
>typedef __int8_t __int_least8_t;
>typedef __uint8_t __uint_least8_t;
>typedef __int16_t __int_least16_t;
>typedef __uint16_t __uint_least16_t;
>typedef __int32_t __int_least32_t;
>typedef __uint32_t __uint_least32_t;
>typedef __int64_t __int_least64_t;
>typedef __uint64_t __uint_least64_t;
>
>
>typedef __int32_t __int_fast8_t;
>typedef __uint32_t __uint_fast8_t;
>typedef __int32_t __int_fast16_t;
>typedef __uint32_t __uint_fast16_t;
>typedef __int32_t __int_fast32_t;
>typedef __uint32_t __uint_fast32_t;
>typedef __int64_t __int_fast64_t;
>typedef __uint64_t __uint_fast64_t;
>
>
>typedef int __intptr_t;
>typedef unsigned int __uintptr_t;
>
>
>typedef __int64_t __intmax_t;
>typedef __uint64_t __uintmax_t;
>
>
>typedef __int32_t __register_t;
>
>
>typedef unsigned long __vaddr_t;
>typedef unsigned long __paddr_t;
>typedef unsigned long __vsize_t;
>typedef unsigned long __psize_t;
>
>
>typedef int __clock_t;
>typedef int __clockid_t;
>typedef long __ptrdiff_t;
>typedef int __time_t;
>typedef int __timer_t;
>
>typedef __builtin_va_list __va_list;
>typedef int __wint_t;
>typedef int __rune_t;
>typedef void * __wctrans_t;
>typedef void * __wctype_t;
>
>typedef unsigned long __cpuid_t;
>typedef __int32_t __dev_t;
>typedef __uint32_t __fixpt_t;
>typedef __uint32_t __gid_t;
>typedef __uint32_t __id_t;
>typedef __uint32_t __in_addr_t;
>typedef __uint16_t __in_port_t;
>typedef __uint32_t __ino_t;
>typedef long __key_t;
>typedef __uint32_t __mode_t;
>typedef __uint32_t __nlink_t;
>typedef __int32_t __pid_t;
>typedef __uint64_t __rlim_t;
>typedef __uint16_t __sa_family_t;
>typedef __int32_t __segsz_t;
>typedef __uint32_t __socklen_t;
>typedef __int32_t __swblk_t;
>typedef __uint32_t __uid_t;
>typedef __uint32_t __useconds_t;
>typedef __int32_t __suseconds_t;
>
>
>
>
>
>typedef union {
> char __mbstate8[128];
> __int64_t __mbstateL;
>} __mbstate_t;
>typedef __int8_t int8_t;
>typedef __uint8_t uint8_t;
>typedef __int16_t int16_t;
>typedef __uint16_t uint16_t;
>typedef __int32_t int32_t;
>typedef __uint32_t uint32_t;
>typedef __int64_t int64_t;
>typedef __uint64_t uint64_t;
>
>
>
>
>
>typedef int8_t int_least8_t;
>typedef int8_t int_fast8_t;
>
>typedef uint8_t uint_least8_t;
>typedef uint8_t uint_fast8_t;
>typedef int16_t int_least16_t;
>typedef int32_t int_fast16_t;
>
>typedef uint16_t uint_least16_t;
>typedef uint32_t uint_fast16_t;
>typedef int32_t int_least32_t;
>typedef int32_t int_fast32_t;
>
>typedef uint32_t uint_least32_t;
>typedef uint32_t uint_fast32_t;
>typedef int64_t int_least64_t;
>typedef int64_t int_fast64_t;
>
>typedef uint64_t uint_least64_t;
>typedef uint64_t uint_fast64_t;
>typedef int intptr_t;
>typedef unsigned int uintptr_t;
>typedef uint64_t uintmax_t;
>typedef int64_t intmax_t;
>typedef long int ssize_t;
>
>
>
>
>
>
>
>
>
>
>
>
>
>typedef struct {
> unsigned long fds_bits [(1024/(8 * sizeof(unsigned long)))];
>} __kernel_fd_set;
>
>typedef void (*__kernel_sighandler_t)(int);
>
>typedef int __kernel_key_t;
>typedef int __kernel_mqd_t;
>
>typedef unsigned long __kernel_ino_t;
>typedef unsigned short __kernel_mode_t;
>typedef unsigned short __kernel_nlink_t;
>typedef long __kernel_off_t;
>typedef int __kernel_pid_t;
>typedef unsigned short __kernel_ipc_pid_t;
>typedef unsigned short __kernel_uid_t;
>typedef unsigned short __kernel_gid_t;
>typedef unsigned int __kernel_size_t;
>typedef int __kernel_ssize_t;
>typedef int __kernel_ptrdiff_t;
>typedef long __kernel_time_t;
>typedef long __kernel_suseconds_t;
>typedef long __kernel_clock_t;
>typedef int __kernel_timer_t;
>typedef int __kernel_clockid_t;
>typedef int __kernel_daddr_t;
>typedef char * __kernel_caddr_t;
>typedef unsigned short __kernel_uid16_t;
>typedef unsigned short __kernel_gid16_t;
>typedef unsigned int __kernel_uid32_t;
>typedef unsigned int __kernel_gid32_t;
>
>typedef unsigned short __kernel_old_uid_t;
>typedef unsigned short __kernel_old_gid_t;
>typedef unsigned short __kernel_old_dev_t;
>
>
>typedef long long __kernel_loff_t;
>
>
>typedef struct {
>
>
>
> int __val[2];
>
>} __kernel_fsid_t;
>typedef unsigned short umode_t;
>
>typedef __signed__ char __s8;
>typedef unsigned char __u8;
>
>typedef __signed__ short __s16;
>typedef unsigned short __u16;
>
>typedef __signed__ int __s32;
>typedef unsigned int __u32;
>
>
>typedef __signed__ long long __s64;
>typedef unsigned long long __u64;
>typedef __u16 __le16;
>typedef __u16 __be16;
>typedef __u32 __le32;
>typedef __u32 __be32;
>
>
>
>
>
>struct ustat {
> __kernel_daddr_t f_tfree;
> __kernel_ino_t f_tinode;
> char f_fname[6];
> char f_fpack[6];
>};
>typedef unsigned long __kernel_blkcnt_t;
>typedef unsigned long __kernel_blksize_t;
>
>
>typedef unsigned long __kernel_fsblkcnt_t;
>typedef unsigned long __kernel_fsfilcnt_t;
>typedef unsigned int __kernel_id_t;
>
>typedef __u32 __kernel_dev_t;
>typedef __kernel_blkcnt_t blkcnt_t;
>typedef __kernel_blksize_t blksize_t;
>typedef __kernel_clock_t clock_t;
>typedef __kernel_clockid_t clockid_t;
>typedef __kernel_dev_t dev_t;
>typedef __kernel_fsblkcnt_t fsblkcnt_t;
>typedef __kernel_fsfilcnt_t fsfilcnt_t;
>typedef __kernel_gid32_t gid_t;
>typedef __kernel_id_t id_t;
>typedef __kernel_ino_t ino_t;
>typedef __kernel_key_t key_t;
>typedef __kernel_mode_t mode_t;
>typedef __kernel_nlink_t nlink_t;
>
>
>typedef __kernel_off_t off_t;
>
>typedef __kernel_loff_t loff_t;
>typedef loff_t off64_t;
>
>typedef __kernel_pid_t pid_t;
>typedef __kernel_suseconds_t suseconds_t;
>typedef __kernel_time_t time_t;
>typedef __kernel_uid32_t uid_t;
>typedef signed long useconds_t;
>
>typedef __kernel_daddr_t daddr_t;
>typedef __kernel_timer_t timer_t;
>typedef __kernel_mqd_t mqd_t;
>
>typedef __kernel_caddr_t caddr_t;
>typedef unsigned int uint_t;
>typedef unsigned int uint;
>
>
>static __inline__ int major(dev_t _dev)
>{
>  return (_dev >> 8) & 0xfff;
>}
>
>static __inline__ int minor(dev_t _dev)
>{
>  return (_dev & 0xff) | ((_dev >> 12) & 0xfff00);
>}
>
>static __inline__ dev_t makedev(int __ma, int __mi)
>{
>  return ((__ma & 0xfff) << 8) | (__mi & 0xff) | ((__mi & 0xfff00) << 12);
>}
>
>
>typedef unsigned char u_char;
>typedef unsigned short u_short;
>typedef unsigned int u_int;
>typedef unsigned long u_long;
>
>typedef uint32_t u_int32_t;
>typedef uint16_t u_int16_t;
>typedef uint8_t u_int8_t;
>typedef uint64_t u_int64_t;
>struct timespec {
> time_t tv_sec;
> long tv_nsec;
>};
>
>
>struct timeval {
> time_t tv_sec;
> suseconds_t tv_usec;
>};
>
>struct timezone {
> int tz_minuteswest;
> int tz_dsttime;
>};
>struct itimerspec {
> struct timespec it_interval;
> struct timespec it_value;
>};
>
>struct itimerval {
> struct timeval it_interval;
> struct timeval it_value;
>};
>
>extern "C" {
>
>extern int gettimeofday(struct timeval *, struct timezone *);
>extern int settimeofday(const struct timeval *, const struct timezone *);
>
>extern int getitimer(int, struct itimerval *);
>extern int setitimer(int, const struct itimerval *, struct itimerval *);
>
>extern int utimes(const char *, const struct timeval *);
>}
>
>
>extern "C" {
>
>extern __attribute__((malloc)) void* malloc(size_t);
>extern __attribute__((malloc)) void* calloc(size_t, size_t);
>extern void* realloc(void *, size_t);
>extern void free(void *);
>
>extern void* memalign(size_t alignment, size_t bytesize);
>extern size_t malloc_usable_size(const void*);
>
>extern void* valloc(size_t bytesize);
>extern void* pvalloc(size_t bytesize);
>
>
>
>struct mallinfo {
>  size_t arena;
>  size_t ordblks;
>  size_t smblks;
>  size_t hblks;
>  size_t hblkhd;
>  size_t usmblks;
>  size_t fsmblks;
>  size_t uordblks;
>  size_t fordblks;
>  size_t keepcost;
>};
>
>
>extern struct mallinfo mallinfo(void);
>
>}
>
>extern "C" {
>
>extern void* memccpy(void *, const void *, int, size_t);
>extern void* memchr(const void *, int, size_t);
>extern void* memrchr(const void *, int, size_t);
>extern int memcmp(const void *, const void *, size_t);
>extern void* memcpy(void *, const void *, size_t);
>extern void* memmove(void *, const void *, size_t);
>extern void* memset(void *, int, size_t);
>extern void* memmem(const void *, size_t, const void *, size_t);
>extern void memswap(void *, void *, size_t);
>
>extern char* index(const char *, int);
>extern char* rindex(const char *, int);
>extern char* strchr(const char *, int);
>extern char* strrchr(const char *, int);
>
>extern size_t strlen(const char *);
>extern int strcmp(const char *, const char *);
>extern char* strcpy(char *, const char *);
>extern char* strcat(char *, const char *);
>
>extern int strcasecmp(const char *, const char *);
>extern int strncasecmp(const char *, const char *, size_t);
>extern char* strdup(const char *);
>
>extern char* strstr(const char *, const char *);
>extern char* strcasestr(const char *haystack, const char *needle);
>extern char* strtok(char *, const char *);
>extern char* strtok_r(char *, const char *, char**);
>
>extern char* strerror(int);
>extern int strerror_r(int errnum, char *buf, size_t n);
>
>extern size_t strnlen(const char *, size_t);
>extern char* strncat(char *, const char *, size_t);
>extern char* strndup(const char *, size_t);
>extern int strncmp(const char *, const char *, size_t);
>extern char* strncpy(char *, const char *, size_t);
>
>extern size_t strlcat(char *, const char *, size_t);
>extern size_t strlcpy(char *, const char *, size_t);
>
>extern size_t strcspn(const char *, const char *);
>extern char* strpbrk(const char *, const char *);
>extern char* strsep(char **, const char *);
>extern size_t strspn(const char *, const char *);
>
>extern char* strsignal(int sig);
>
>extern int strcoll(const char *, const char *);
>extern size_t strxfrm(char *, const char *, size_t);
>
>}
>extern "C" {
>
>
>
>extern "C" {
>
>
>typedef struct locale_struct* locale_t;
>
>struct locale_struct {
>    void* dummy;
>};
>
>
>}
>
>ssize_t strfmon(char *__restrict__, size_t, const char *__restrict__, ...);
>ssize_t strfmon_l(char *__restrict__, size_t, locale_t, const char *__restrict__, ...);
>
>
>}
>
>
>extern "C" {
>
>
>int strcoll_l(const char*, const char*, locale_t);
>size_t strxfrm_l(char *, const char *, size_t, locale_t);
>
>
>}
>
>struct siginfo;
>
>
>typedef unsigned long sigset_t;
>typedef void __signalfn_t(int);
>typedef __signalfn_t *__sighandler_t;
>
>typedef void __restorefn_t(void);
>typedef __restorefn_t *__sigrestore_t;
>
>struct sigaction {
> union {
> __sighandler_t _sa_handler;
> void (*_sa_sigaction)(int, struct siginfo *, void *);
> } _u;
> sigset_t sa_mask;
> unsigned long sa_flags;
> void (*sa_restorer)(void);
>};
>
>
>
>
>typedef struct sigaltstack {
> void *ss_sp;
> int ss_flags;
> size_t ss_size;
>} stack_t;
>struct sigcontext {
> unsigned long trap_no;
> unsigned long error_code;
> unsigned long oldmask;
> unsigned long arm_r0;
> unsigned long arm_r1;
> unsigned long arm_r2;
> unsigned long arm_r3;
> unsigned long arm_r4;
> unsigned long arm_r5;
> unsigned long arm_r6;
> unsigned long arm_r7;
> unsigned long arm_r8;
> unsigned long arm_r9;
> unsigned long arm_r10;
> unsigned long arm_fp;
> unsigned long arm_ip;
> unsigned long arm_sp;
> unsigned long arm_lr;
> unsigned long arm_pc;
> unsigned long arm_cpsr;
> unsigned long fault_address;
>};
>
>
>typedef union sigval {
> int sival_int;
> void *sival_ptr;
>} sigval_t;
>typedef struct siginfo {
> int si_signo;
> int si_errno;
> int si_code;
>
> union {
> int _pad[((128 - (3 * sizeof(int))) / sizeof(int))];
>
> struct {
> pid_t _pid;
> __kernel_uid32_t _uid;
> } _kill;
>
> struct {
> timer_t _tid;
> int _overrun;
> char _pad[sizeof( __kernel_uid32_t) - sizeof(int)];
> sigval_t _sigval;
> int _sys_private;
> } _timer;
>
> struct {
> pid_t _pid;
> __kernel_uid32_t _uid;
> sigval_t _sigval;
> } _rt;
>
> struct {
> pid_t _pid;
> __kernel_uid32_t _uid;
> int _status;
> clock_t _utime;
> clock_t _stime;
> } _sigchld;
>
> struct {
> void *_addr;
>
>
>
> } _sigfault;
>
> struct {
> long _band;
> int _fd;
> } _sigpoll;
> } _sifields;
>} siginfo_t;
>typedef struct sigevent {
> sigval_t sigev_value;
> int sigev_signo;
> int sigev_notify;
> union {
> int _pad[((64 - (sizeof(int) * 2 + sizeof(sigval_t))) / sizeof(int))];
> int _tid;
>
> struct {
> void (*_function)(sigval_t);
> void *_attribute;
> } _sigev_thread;
> } _sigev_un;
>} sigevent_t;
>
>
>extern "C" {
>
>typedef int sig_atomic_t;
>extern const char * const sys_siglist[];
>extern const char * const sys_signame[];
>
>static __inline__ int sigismember(sigset_t *set, int signum)
>{
>    unsigned long *local_set = (unsigned long *)set;
>    signum--;
>    return (int)((local_set[signum/32] >> (signum%32)) & 1);
>}
>
>
>static __inline__ int sigaddset(sigset_t *set, int signum)
>{
>    unsigned long *local_set = (unsigned long *)set;
>    signum--;
>    local_set[signum/32] |= 1UL << (signum%32);
>    return 0;
>}
>
>
>static __inline__ int sigdelset(sigset_t *set, int signum)
>{
>    unsigned long *local_set = (unsigned long *)set;
>    signum--;
>    local_set[signum/32] &= ~(1UL << (signum%32));
>    return 0;
>}
>
>
>static __inline__ int sigemptyset(sigset_t *set)
>{
>    memset(set, 0, sizeof *set);
>    return 0;
>}
>
>static __inline__ int sigfillset(sigset_t *set)
>{
>    memset(set, ~0, sizeof *set);
>    return 0;
>}
>
>
>
>typedef void (*sig_t)(int);
>typedef sig_t sighandler_t;
>
>
>extern __sighandler_t sysv_signal(int, __sighandler_t);
>extern __sighandler_t bsd_signal(int, __sighandler_t);
>
>
>static __inline__ __sighandler_t signal(int s, __sighandler_t f)
>{
>    return bsd_signal(s,f);
>}
>
>
>extern __sighandler_t __signal(int, __sighandler_t, int);
>
>extern int sigprocmask(int, const sigset_t *, sigset_t *);
>extern int sigaction(int, const struct sigaction *, struct sigaction *);
>
>extern int sigpending(sigset_t *);
>extern int sigsuspend(const sigset_t *);
>extern int sigwait(const sigset_t *set, int *sig);
>extern int siginterrupt(int sig, int flag);
>
>extern int raise(int);
>extern int kill(pid_t, int);
>extern int killpg(int pgrp, int sig);
>extern int sigaltstack(const stack_t *ss, stack_t *oss);
>
>
>}
>
>extern "C" {
>
>typedef __kernel_fd_set fd_set;
>
>extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
>extern int pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *errfds,
>                   const struct timespec *timeout, const sigset_t *sigmask);
>
>}
>extern "C" {
>extern int sysconf(int name);
>
>}
>typedef struct __user_cap_header_struct {
> __u32 version;
> int pid;
>} *cap_user_header_t;
>
>typedef struct __user_cap_data_struct {
> __u32 effective;
> __u32 permitted;
> __u32 inheritable;
>} *cap_user_data_t;
>extern "C" {
>extern long fpathconf(int fildes, int name);
>extern long pathconf(const char *path, int name);
>
>}
>
>extern "C" {
>extern char **environ;
>extern __attribute__((__noreturn__)) void _exit(int);
>
>extern pid_t fork(void);
>extern pid_t vfork(void);
>extern pid_t getpid(void);
>extern pid_t gettid(void);
>extern pid_t getpgid(pid_t);
>extern int setpgid(pid_t, pid_t);
>extern pid_t getppid(void);
>extern pid_t getpgrp(void);
>extern int setpgrp(void);
>extern pid_t setsid(void);
>
>extern int execv(const char *, char * const *);
>extern int execvp(const char *, char * const *);
>extern int execve(const char *, char * const *, char * const *);
>extern int execl(const char *, const char *, ...);
>extern int execlp(const char *, const char *, ...);
>extern int execle(const char *, const char *, ...);
>extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
>extern int capset(cap_user_header_t hdrp, const cap_user_data_t datap);
>
>
>extern int prctl(int option, ...);
>
>extern int nice(int);
>
>extern int setuid(uid_t);
>extern uid_t getuid(void);
>extern int seteuid(uid_t);
>extern uid_t geteuid(void);
>extern int setgid(gid_t);
>extern gid_t getgid(void);
>extern int setegid(gid_t);
>extern gid_t getegid(void);
>extern int getgroups(int, gid_t *);
>extern int setgroups(size_t, const gid_t *);
>extern int setreuid(uid_t, uid_t);
>extern int setregid(gid_t, gid_t);
>extern int setresuid(uid_t, uid_t, uid_t);
>extern int setresgid(gid_t, gid_t, gid_t);
>extern int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
>extern int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
>extern int issetugid(void);
>extern char* getlogin(void);
>extern char* getusershell(void);
>extern void setusershell(void);
>extern void endusershell(void);
>extern int access(const char *, int);
>extern int link(const char *, const char *);
>extern int unlink(const char *);
>extern int chdir(const char *);
>extern int fchdir(int);
>extern int rmdir(const char *);
>extern int pipe(int *);
>
>extern int pipe2(int *, int);
>
>extern int chroot(const char *);
>extern int symlink(const char *, const char *);
>extern int readlink(const char *, char *, size_t);
>extern int chown(const char *, uid_t, gid_t);
>extern int fchown(int, uid_t, gid_t);
>extern int lchown(const char *, uid_t, gid_t);
>extern int truncate(const char *, off_t);
>extern char *getcwd(char *, size_t);
>
>extern int sync(void);
>
>extern int close(int);
>extern off_t lseek(int, off_t, int);
>extern off64_t lseek64(int, off64_t, int);
>
>extern ssize_t read(int, void *, size_t);
>extern ssize_t write(int, const void *, size_t);
>extern ssize_t pread(int, void *, size_t, off_t);
>extern ssize_t pwrite(int, const void *, size_t, off_t);
>
>extern int dup(int);
>extern int dup2(int, int);
>extern int fcntl(int, int, ...);
>extern int ioctl(int, int, ...);
>extern int flock(int, int);
>extern int fsync(int);
>extern int fdatasync(int);
>extern int ftruncate(int, off_t);
>
>extern int pause(void);
>extern unsigned int alarm(unsigned int);
>extern unsigned int sleep(unsigned int);
>extern int usleep(unsigned long);
>
>extern int gethostname(char *, size_t);
>
>extern int getdtablesize(void);
>
>extern void *__brk(void *);
>extern int brk(void *);
>extern void *sbrk(ptrdiff_t);
>
>extern int getopt(int, char * const *, const char *);
>extern char *optarg;
>extern int optind, opterr, optopt;
>
>extern int isatty(int);
>extern char* ttyname(int);
>extern int ttyname_r(int, char*, size_t);
>
>extern int acct(const char* filepath);
>
>static __inline__ int getpagesize(void) {
>  extern unsigned int __page_size;
>  return __page_size;
>}
>static __inline__ int __getpageshift(void) {
>  extern unsigned int __page_shift;
>  return __page_shift;
>}
>
>extern int sysconf(int name);
>
>extern int daemon(int, int);
>
>
>extern int cacheflush(long start, long end, long flags);
>
>extern pid_t tcgetpgrp(int fd);
>extern int tcsetpgrp(int fd, pid_t _pid);
>}
>
>
>       
>extern "C" {
>__uint64_t htobe64(__uint64_t);
>__uint32_t htobe32(__uint32_t);
>__uint16_t htobe16(__uint16_t);
>__uint64_t betoh64(__uint64_t);
>__uint32_t betoh32(__uint32_t);
>__uint16_t betoh16(__uint16_t);
>
>__uint64_t htole64(__uint64_t);
>__uint32_t htole32(__uint32_t);
>__uint16_t htole16(__uint16_t);
>__uint64_t letoh64(__uint64_t);
>__uint32_t letoh32(__uint32_t);
>__uint16_t letoh16(__uint16_t);
>}
>namespace std {
>namespace __1 {
>}
>using namespace __1 __attribute__((__strong__));
>}
>
>
>
>       
>
>
>namespace std { namespace __1 {
>
>using ::ptrdiff_t;
>using ::size_t;
>
>
>
>using ::max_align_t;
>} }
>
>
>
>namespace std
>{
>    typedef decltype(nullptr) nullptr_t;
>}
>
>
>       
>
>
>namespace std { namespace __1 {
>
>template <bool _Bp, class _If, class _Then>
>    struct __attribute__ ((__visibility__("default"))) conditional {typedef _If type;};
>template <class _If, class _Then>
>    struct __attribute__ ((__visibility__("default"))) conditional<false, _If, _Then> {typedef _Then type;};
>
>
>
>
>
>template <bool, class _Tp = void> struct __attribute__ ((__visibility__("default"))) enable_if {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) enable_if<true, _Tp> {typedef _Tp type;};
>
>
>
>
>
>
>struct __two {char __lx[2];};
>
>
>
>template <class _Tp, _Tp __v>
>struct __attribute__ ((__visibility__("default"))) integral_constant
>{
>    static constexpr const _Tp value = __v;
>    typedef _Tp value_type;
>    typedef integral_constant type;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        constexpr operator value_type() const throw() {return value;}
>
>
>
>
>};
>
>template <class _Tp, _Tp __v>
>constexpr const _Tp integral_constant<_Tp, __v>::value;
>
>typedef integral_constant<bool, true> true_type;
>typedef integral_constant<bool, false> false_type;
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_const : public false_type {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_const<_Tp const> : public true_type {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_volatile : public false_type {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_volatile<_Tp volatile> : public true_type {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_const {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_const<const _Tp> {typedef _Tp type;};
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_volatile {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_volatile<volatile _Tp> {typedef _Tp type;};
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_cv
>{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
>
>
>
>
>
>
>template <class _Tp> struct __libcpp_is_void : public false_type {};
>template <> struct __libcpp_is_void<void> : public true_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_void
>    : public __libcpp_is_void<typename remove_cv<_Tp>::type> {};
>
>
>
>template <class _Tp> struct __is_nullptr_t_impl : public false_type {};
>template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) __is_nullptr_t
>    : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};
>template <class _Tp> struct __libcpp_is_integral : public false_type {};
>template <> struct __libcpp_is_integral<bool> : public true_type {};
>template <> struct __libcpp_is_integral<char> : public true_type {};
>template <> struct __libcpp_is_integral<signed char> : public true_type {};
>template <> struct __libcpp_is_integral<unsigned char> : public true_type {};
>template <> struct __libcpp_is_integral<wchar_t> : public true_type {};
>
>template <> struct __libcpp_is_integral<char16_t> : public true_type {};
>template <> struct __libcpp_is_integral<char32_t> : public true_type {};
>
>template <> struct __libcpp_is_integral<short> : public true_type {};
>template <> struct __libcpp_is_integral<unsigned short> : public true_type {};
>template <> struct __libcpp_is_integral<int> : public true_type {};
>template <> struct __libcpp_is_integral<unsigned int> : public true_type {};
>template <> struct __libcpp_is_integral<long> : public true_type {};
>template <> struct __libcpp_is_integral<unsigned long> : public true_type {};
>template <> struct __libcpp_is_integral<long long> : public true_type {};
>template <> struct __libcpp_is_integral<unsigned long long> : public true_type {};
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_integral
>    : public __libcpp_is_integral<typename remove_cv<_Tp>::type> {};
>
>
>
>template <class _Tp> struct __libcpp_is_floating_point : public false_type {};
>template <> struct __libcpp_is_floating_point<float> : public true_type {};
>template <> struct __libcpp_is_floating_point<double> : public true_type {};
>template <> struct __libcpp_is_floating_point<long double> : public true_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_floating_point
>    : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_array
>    : public false_type {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_array<_Tp[]>
>    : public true_type {};
>template <class _Tp, size_t _Np> struct __attribute__ ((__visibility__("default"))) is_array<_Tp[_Np]>
>    : public true_type {};
>
>
>
>template <class _Tp> struct __libcpp_is_pointer : public false_type {};
>template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_pointer
>    : public __libcpp_is_pointer<typename remove_cv<_Tp>::type> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_lvalue_reference : public false_type {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_lvalue_reference<_Tp&> : public true_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_rvalue_reference : public false_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_rvalue_reference<_Tp&&> : public true_type {};
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_reference : public false_type {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_reference<_Tp&> : public true_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_reference<_Tp&&> : public true_type {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_union
>    : public integral_constant<bool, __is_union(_Tp)> {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_class
>    : public integral_constant<bool, __is_class(_Tp)> {};
>template <class _Tp, class _Up> struct __attribute__ ((__visibility__("default"))) is_same : public false_type {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_same<_Tp, _Tp> : public true_type {};
>
>
>
>namespace __libcpp_is_function_imp
>{
>template <class _Tp> char __test(_Tp*);
>template <class _Tp> __two __test(...);
>template <class _Tp> _Tp& __source();
>}
>
>template <class _Tp, bool = is_class<_Tp>::value ||
>                            is_union<_Tp>::value ||
>                            is_void<_Tp>::value ||
>                            is_reference<_Tp>::value ||
>                            __is_nullptr_t<_Tp>::value >
>struct __libcpp_is_function
>    : public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>())) == 1>
>    {};
>template <class _Tp> struct __libcpp_is_function<_Tp, true> : public false_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_function
>    : public __libcpp_is_function<_Tp> {};
>
>
>
>
>
>
>
>template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
>struct __member_pointer_traits_imp
>{
>};
>
>
>namespace __libcpp_is_member_function_pointer_imp {
> template <typename _Tp>
> char __test(typename std::__member_pointer_traits_imp<_Tp, true, false>::_FnType *);
>
> template <typename>
> std::__two __test(...);
>};
>
>template <class _Tp> struct __libcpp_is_member_function_pointer
>    : public integral_constant<bool, sizeof(__libcpp_is_member_function_pointer_imp::__test<_Tp>(nullptr)) == 1> {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_member_function_pointer
>    : public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type> {};
>
>
>
>template <class _Tp> struct __libcpp_is_member_pointer : public false_type {};
>template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> : public true_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_member_pointer
>    : public __libcpp_is_member_pointer<typename remove_cv<_Tp>::type> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_member_object_pointer
>    : public integral_constant<bool, is_member_pointer<_Tp>::value &&
>                                    !is_member_function_pointer<_Tp>::value> {};
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_enum
>    : public integral_constant<bool, __is_enum(_Tp)> {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_arithmetic
>    : public integral_constant<bool, is_integral<_Tp>::value ||
>                                     is_floating_point<_Tp>::value> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_fundamental
>    : public integral_constant<bool, is_void<_Tp>::value ||
>                                     __is_nullptr_t<_Tp>::value ||
>                                     is_arithmetic<_Tp>::value> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_scalar
>    : public integral_constant<bool, is_arithmetic<_Tp>::value ||
>                                     is_member_pointer<_Tp>::value ||
>                                     is_pointer<_Tp>::value ||
>                                     __is_nullptr_t<_Tp>::value ||
>                                     is_enum<_Tp>::value > {};
>
>template <> struct __attribute__ ((__visibility__("default"))) is_scalar<nullptr_t> : public true_type {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_object
>    : public integral_constant<bool, is_scalar<_Tp>::value ||
>                                     is_array<_Tp>::value ||
>                                     is_union<_Tp>::value ||
>                                     is_class<_Tp>::value > {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_compound
>    : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
>
>
>
>template <class _Tp, bool = is_reference<_Tp>::value ||
>                            is_function<_Tp>::value ||
>                            is_const<_Tp>::value >
>struct __add_const {typedef _Tp type;};
>
>template <class _Tp>
>struct __add_const<_Tp, false> {typedef const _Tp type;};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) add_const
>    {typedef typename __add_const<_Tp>::type type;};
>
>
>
>
>
>
>
>template <class _Tp, bool = is_reference<_Tp>::value ||
>                            is_function<_Tp>::value ||
>                            is_volatile<_Tp>::value >
>struct __add_volatile {typedef _Tp type;};
>
>template <class _Tp>
>struct __add_volatile<_Tp, false> {typedef volatile _Tp type;};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) add_volatile
>    {typedef typename __add_volatile<_Tp>::type type;};
>
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) add_cv
>    {typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};
>
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_reference {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_reference<_Tp&> {typedef _Tp type;};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_reference<_Tp&&> {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) add_lvalue_reference {typedef _Tp& type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) add_lvalue_reference<_Tp&> {typedef _Tp& type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_lvalue_reference<void> {typedef void type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_lvalue_reference<const void> {typedef const void type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_lvalue_reference<volatile void> {typedef volatile void type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_lvalue_reference<const volatile void> {typedef const volatile void type;};
>
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) add_rvalue_reference {typedef _Tp&& type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_rvalue_reference<void> {typedef void type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_rvalue_reference<const void> {typedef const void type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_rvalue_reference<volatile void> {typedef volatile void type;};
>template <> struct __attribute__ ((__visibility__("default"))) add_rvalue_reference<const volatile void> {typedef const volatile void type;};
>template <class _Tp>
>typename add_rvalue_reference<_Tp>::type
>declval() throw();
>struct __any
>{
>    __any(...);
>};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_pointer {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_pointer<_Tp*> {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_pointer<_Tp* const> {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_pointer<_Tp* volatile> {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_pointer<_Tp* const volatile> {typedef _Tp type;};
>
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) add_pointer
>    {typedef typename remove_reference<_Tp>::type* type;};
>
>
>
>
>
>
>
>template <class _Tp, bool = is_integral<_Tp>::value>
>struct __libcpp_is_signed_impl : public integral_constant<bool, _Tp(-1) < _Tp(0)> {};
>
>template <class _Tp>
>struct __libcpp_is_signed_impl<_Tp, false> : public true_type {};
>
>template <class _Tp, bool = is_arithmetic<_Tp>::value>
>struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};
>
>template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_signed : public __libcpp_is_signed<_Tp> {};
>
>
>
>template <class _Tp, bool = is_integral<_Tp>::value>
>struct __libcpp_is_unsigned_impl : public integral_constant<bool, _Tp(0) < _Tp(-1)> {};
>
>template <class _Tp>
>struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {};
>
>template <class _Tp, bool = is_arithmetic<_Tp>::value>
>struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};
>
>template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_unsigned : public __libcpp_is_unsigned<_Tp> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) rank
>    : public integral_constant<size_t, 0> {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) rank<_Tp[]>
>    : public integral_constant<size_t, rank<_Tp>::value + 1> {};
>template <class _Tp, size_t _Np> struct __attribute__ ((__visibility__("default"))) rank<_Tp[_Np]>
>    : public integral_constant<size_t, rank<_Tp>::value + 1> {};
>
>
>
>template <class _Tp, unsigned _Ip = 0> struct __attribute__ ((__visibility__("default"))) extent
>    : public integral_constant<size_t, 0> {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) extent<_Tp[], 0>
>    : public integral_constant<size_t, 0> {};
>template <class _Tp, unsigned _Ip> struct __attribute__ ((__visibility__("default"))) extent<_Tp[], _Ip>
>    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
>template <class _Tp, size_t _Np> struct __attribute__ ((__visibility__("default"))) extent<_Tp[_Np], 0>
>    : public integral_constant<size_t, _Np> {};
>template <class _Tp, size_t _Np, unsigned _Ip> struct __attribute__ ((__visibility__("default"))) extent<_Tp[_Np], _Ip>
>    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_extent
>    {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_extent<_Tp[]>
>    {typedef _Tp type;};
>template <class _Tp, size_t _Np> struct __attribute__ ((__visibility__("default"))) remove_extent<_Tp[_Np]>
>    {typedef _Tp type;};
>
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_all_extents
>    {typedef _Tp type;};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) remove_all_extents<_Tp[]>
>    {typedef typename remove_all_extents<_Tp>::type type;};
>template <class _Tp, size_t _Np> struct __attribute__ ((__visibility__("default"))) remove_all_extents<_Tp[_Np]>
>    {typedef typename remove_all_extents<_Tp>::type type;};
>
>
>
>
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) decay
>{
>private:
>    typedef typename remove_reference<_Tp>::type _Up;
>public:
>    typedef typename conditional
>                     <
>                         is_array<_Up>::value,
>                         typename remove_extent<_Up>::type*,
>                         typename conditional
>                         <
>                              is_function<_Up>::value,
>                              typename add_pointer<_Up>::type,
>                              typename remove_cv<_Up>::type
>                         >::type
>                     >::type type;
>};
>
>
>
>
>
>
>namespace __is_abstract_imp
>{
>template <class _Tp> char __test(_Tp (*)[1]);
>template <class _Tp> __two __test(...);
>}
>
>template <class _Tp, bool = is_class<_Tp>::value>
>struct __libcpp_abstract : public integral_constant<bool, sizeof(__is_abstract_imp::__test<_Tp>(0)) != 1> {};
>
>template <class _Tp> struct __libcpp_abstract<_Tp, false> : public false_type {};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_abstract : public __libcpp_abstract<_Tp> {};
>template <class _Bp, class _Dp>
>struct __attribute__ ((__visibility__("default"))) is_base_of
>    : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
>namespace __is_convertible_imp
>{
>
>
>template <class _Tp> typename add_rvalue_reference<_Tp>::type __create();
>
>
>
>
>template <class _Tp> void helper(_Tp);
>
>template <class _Tp, class _Tf, class = decltype(helper<_Tp>(__create<_Tf>()))> char __test(int);
>template <class _Tp, class _Tf> __two __test(...);
>
>template <class _Tp, bool _IsArray = is_array<_Tp>::value,
>                     bool _IsFunction = is_function<_Tp>::value,
>                     bool _IsVoid = is_void<_Tp>::value>
>                     struct __is_array_function_or_void {enum {value = 0};};
>template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> {enum {value = 1};};
>template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> {enum {value = 2};};
>template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};};
>}
>
>template <class _Tp,
>    unsigned = __is_convertible_imp::__is_array_function_or_void<typename remove_reference<_Tp>::type>::value>
>struct __is_convertible_check
>{
>    static const size_t __v = 0;
>};
>
>template <class _Tp>
>struct __is_convertible_check<_Tp, 0>
>{
>    static const size_t __v = sizeof(_Tp);
>};
>
>template <class _T1, class _T2,
>    unsigned _T1_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T1>::value,
>    unsigned _T2_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T2>::value>
>struct __is_convertible
>    : public integral_constant<bool,
>
>        sizeof(__is_convertible_imp::__test<_T2, _T1>(1)) == 1
>    >
>{};
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 0> : false_type {};
>
>template <class _T1> struct __is_convertible<_T1, const typename remove_const<_T1>::type&, 1, 0> : true_type {};
>
>template <class _T1> struct __is_convertible<_T1, _T1&&, 1, 0> : true_type {};
>template <class _T1> struct __is_convertible<_T1, const typename remove_const<_T1>::type&&, 1, 0> : true_type {};
>template <class _T1> struct __is_convertible<_T1, volatile typename remove_volatile<_T1>::type&&, 1, 0> : true_type {};
>template <class _T1> struct __is_convertible<_T1, const volatile typename remove_cv<_T1>::type&&, 1, 0> : true_type {};
>
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2*, 1, 0>
>    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*>::value> {};
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2* const, 1, 0>
>    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*const>::value> {};
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2* volatile, 1, 0>
>    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*volatile>::value> {};
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2* const volatile, 1, 0>
>    : public integral_constant<bool, __is_convertible<typename remove_all_extents<_T1>::type*, _T2*const volatile>::value> {};
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 0> : public false_type {};
>
>template <class _T1> struct __is_convertible<_T1, _T1&&, 2, 0> : public true_type {};
>
>template <class _T1> struct __is_convertible<_T1, _T1&, 2, 0> : public true_type {};
>template <class _T1> struct __is_convertible<_T1, _T1*, 2, 0> : public true_type {};
>template <class _T1> struct __is_convertible<_T1, _T1*const, 2, 0> : public true_type {};
>template <class _T1> struct __is_convertible<_T1, _T1*volatile, 2, 0> : public true_type {};
>template <class _T1> struct __is_convertible<_T1, _T1*const volatile, 2, 0> : public true_type {};
>
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 0> : public false_type {};
>
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 1> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 1> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 1> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 1> : public false_type {};
>
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 2> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 2> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {};
>
>
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
>template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};
>
>template <class _T1, class _T2> struct __attribute__ ((__visibility__("default"))) is_convertible
>    : public __is_convertible<_T1, _T2>
>{
>    static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
>    static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
>};
>
>
>
>
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_empty
>    : public integral_constant<bool, __is_empty(_Tp)> {};
>template<typename _Tp> char &__is_polymorphic_impl(
>    typename enable_if<sizeof((_Tp*)dynamic_cast<const volatile void*>(declval<_Tp*>())) != 0,
>                       int>::type);
>template<typename _Tp> __two &__is_polymorphic_impl(...);
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_polymorphic
>    : public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {};
>
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) has_virtual_destructor
>    : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) alignment_of
>    : public integral_constant<size_t, __alignof__(_Tp)> {};
>
>
>
>template <class _Hp, class _Tp>
>struct __type_list
>{
>    typedef _Hp _Head;
>    typedef _Tp _Tail;
>};
>
>struct __nat
>{
>
>    __nat() = delete;
>    __nat(const __nat&) = delete;
>    __nat& operator=(const __nat&) = delete;
>    ~__nat() = delete;
>
>};
>
>template <class _Tp>
>struct __align_type
>{
>    static const size_t value = alignment_of<_Tp>::value;
>    typedef _Tp type;
>};
>
>struct __struct_double {long double __lx;};
>struct __struct_double4 {double __lx[4];};
>
>typedef
>    __type_list<__align_type<unsigned char>,
>    __type_list<__align_type<unsigned short>,
>    __type_list<__align_type<unsigned int>,
>    __type_list<__align_type<unsigned long>,
>    __type_list<__align_type<unsigned long long>,
>    __type_list<__align_type<double>,
>    __type_list<__align_type<long double>,
>    __type_list<__align_type<__struct_double>,
>    __type_list<__align_type<__struct_double4>,
>    __type_list<__align_type<int*>,
>    __nat
>    > > > > > > > > > > __all_types;
>
>template <class _TL, size_t _Align> struct __find_pod;
>
>template <class _Hp, size_t _Align>
>struct __find_pod<__type_list<_Hp, __nat>, _Align>
>{
>    typedef typename conditional<
>                             _Align == _Hp::value,
>                             typename _Hp::type,
>                             void
>                         >::type type;
>};
>
>template <class _Hp, class _Tp, size_t _Align>
>struct __find_pod<__type_list<_Hp, _Tp>, _Align>
>{
>    typedef typename conditional<
>                             _Align == _Hp::value,
>                             typename _Hp::type,
>                             typename __find_pod<_Tp, _Align>::type
>                         >::type type;
>};
>
>template <class _TL, size_t _Len> struct __find_max_align;
>
>template <class _Hp, size_t _Len>
>struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {};
>
>template <size_t _Len, size_t _A1, size_t _A2>
>struct __select_align
>{
>private:
>    static const size_t __min = _A2 < _A1 ? _A2 : _A1;
>    static const size_t __max = _A1 < _A2 ? _A2 : _A1;
>public:
>    static const size_t value = _Len < __max ? __min : __max;
>};
>
>template <class _Hp, class _Tp, size_t _Len>
>struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
>    : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
>
>template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
>struct __attribute__ ((__visibility__("default"))) aligned_storage
>{
>    typedef typename __find_pod<__all_types, _Align>::type _Aligner;
>    static_assert(!is_void<_Aligner>::value, "");
>    union type
>    {
>        _Aligner __align;
>        unsigned char __data[_Len];
>    };
>};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x1>{ struct __attribute__((__aligned__(0x1))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x2>{ struct __attribute__((__aligned__(0x2))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x4>{ struct __attribute__((__aligned__(0x4))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x8>{ struct __attribute__((__aligned__(0x8))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x10>{ struct __attribute__((__aligned__(0x10))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x20>{ struct __attribute__((__aligned__(0x20))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x40>{ struct __attribute__((__aligned__(0x40))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x80>{ struct __attribute__((__aligned__(0x80))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x100>{ struct __attribute__((__aligned__(0x100))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x200>{ struct __attribute__((__aligned__(0x200))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x400>{ struct __attribute__((__aligned__(0x400))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x800>{ struct __attribute__((__aligned__(0x800))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x1000>{ struct __attribute__((__aligned__(0x1000))) type { unsigned char __lx[_Len]; };};
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x2000>{ struct __attribute__((__aligned__(0x2000))) type { unsigned char __lx[_Len]; };};
>
>
>template <size_t _Len>struct __attribute__ ((__visibility__("default"))) aligned_storage<_Len, 0x4000>{ struct __attribute__((__aligned__(0x4000))) type { unsigned char __lx[_Len]; };};
>template <size_t _I0, size_t ..._In>
>struct __static_max;
>
>template <size_t _I0>
>struct __static_max<_I0>
>{
>    static const size_t value = _I0;
>};
>
>template <size_t _I0, size_t _I1, size_t ..._In>
>struct __static_max<_I0, _I1, _In...>
>{
>    static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
>                                             __static_max<_I1, _In...>::value;
>};
>
>template <size_t _Len, class _Type0, class ..._Types>
>struct aligned_union
>{
>    static const size_t alignment_value = __static_max<__alignof__(_Type0),
>                                                       __alignof__(_Types)...>::value;
>    static const size_t __len = __static_max<_Len, sizeof(_Type0),
>                                             sizeof(_Types)...>::value;
>    typedef typename aligned_storage<__len, alignment_value>::type type;
>};
>
>
>
>
>
>
>
>template <class _Tp>
>struct __numeric_type
>{
>   static void __test(...);
>   static float __test(float);
>   static double __test(char);
>   static double __test(int);
>   static double __test(unsigned);
>   static double __test(long);
>   static double __test(unsigned long);
>   static double __test(long long);
>   static double __test(unsigned long long);
>   static double __test(double);
>   static long double __test(long double);
>
>   typedef decltype(__test(declval<_Tp>())) type;
>   static const bool value = !is_same<type, void>::value;
>};
>
>template <>
>struct __numeric_type<void>
>{
>   static const bool value = true;
>};
>
>
>
>template <class _A1, class _A2 = void, class _A3 = void,
>          bool = __numeric_type<_A1>::value &&
>                 __numeric_type<_A2>::value &&
>                 __numeric_type<_A3>::value>
>class __promote
>{
>    static const bool value = false;
>};
>
>template <class _A1, class _A2, class _A3>
>class __promote<_A1, _A2, _A3, true>
>{
>private:
>    typedef typename __promote<_A1>::type __type1;
>    typedef typename __promote<_A2>::type __type2;
>    typedef typename __promote<_A3>::type __type3;
>public:
>    typedef decltype(__type1() + __type2() + __type3()) type;
>    static const bool value = true;
>};
>
>template <class _A1, class _A2>
>class __promote<_A1, _A2, void, true>
>{
>private:
>    typedef typename __promote<_A1>::type __type1;
>    typedef typename __promote<_A2>::type __type2;
>public:
>    typedef decltype(__type1() + __type2()) type;
>    static const bool value = true;
>};
>
>template <class _A1>
>class __promote<_A1, void, void, true>
>{
>public:
>    typedef typename __numeric_type<_A1>::type type;
>    static const bool value = true;
>    static const bool __does_not_throw = false;
>};
>typedef
>    __type_list<signed char,
>    __type_list<signed short,
>    __type_list<signed int,
>    __type_list<signed long,
>    __type_list<signed long long,
>
>
>
>    __nat
>
>
>
>    > > > > > __signed_types;
>
>typedef
>    __type_list<unsigned char,
>    __type_list<unsigned short,
>    __type_list<unsigned int,
>    __type_list<unsigned long,
>    __type_list<unsigned long long,
>
>
>
>    __nat
>
>
>
>    > > > > > __unsigned_types;
>
>template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;
>
>template <class _Hp, class _Tp, size_t _Size>
>struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
>{
>    typedef _Hp type;
>};
>
>template <class _Hp, class _Tp, size_t _Size>
>struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
>{
>    typedef typename __find_first<_Tp, _Size>::type type;
>};
>
>template <class _Tp, class _Up, bool = is_const<typename remove_reference<_Tp>::type>::value,
>                             bool = is_volatile<typename remove_reference<_Tp>::type>::value>
>struct __apply_cv
>{
>    typedef _Up type;
>};
>
>template <class _Tp, class _Up>
>struct __apply_cv<_Tp, _Up, true, false>
>{
>    typedef const _Up type;
>};
>
>template <class _Tp, class _Up>
>struct __apply_cv<_Tp, _Up, false, true>
>{
>    typedef volatile _Up type;
>};
>
>template <class _Tp, class _Up>
>struct __apply_cv<_Tp, _Up, true, true>
>{
>    typedef const volatile _Up type;
>};
>
>template <class _Tp, class _Up>
>struct __apply_cv<_Tp&, _Up, false, false>
>{
>    typedef _Up& type;
>};
>
>template <class _Tp, class _Up>
>struct __apply_cv<_Tp&, _Up, true, false>
>{
>    typedef const _Up& type;
>};
>
>template <class _Tp, class _Up>
>struct __apply_cv<_Tp&, _Up, false, true>
>{
>    typedef volatile _Up& type;
>};
>
>template <class _Tp, class _Up>
>struct __apply_cv<_Tp&, _Up, true, true>
>{
>    typedef const volatile _Up& type;
>};
>
>template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
>struct __make_signed {};
>
>template <class _Tp>
>struct __make_signed<_Tp, true>
>{
>    typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
>};
>
>template <> struct __make_signed<bool, true> {};
>template <> struct __make_signed< signed short, true> {typedef short type;};
>template <> struct __make_signed<unsigned short, true> {typedef short type;};
>template <> struct __make_signed< signed int, true> {typedef int type;};
>template <> struct __make_signed<unsigned int, true> {typedef int type;};
>template <> struct __make_signed< signed long, true> {typedef long type;};
>template <> struct __make_signed<unsigned long, true> {typedef long type;};
>template <> struct __make_signed< signed long long, true> {typedef long long type;};
>template <> struct __make_signed<unsigned long long, true> {typedef long long type;};
>
>
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) make_signed
>{
>    typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
>};
>
>
>
>
>
>template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
>struct __make_unsigned {};
>
>template <class _Tp>
>struct __make_unsigned<_Tp, true>
>{
>    typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
>};
>
>template <> struct __make_unsigned<bool, true> {};
>template <> struct __make_unsigned< signed short, true> {typedef unsigned short type;};
>template <> struct __make_unsigned<unsigned short, true> {typedef unsigned short type;};
>template <> struct __make_unsigned< signed int, true> {typedef unsigned int type;};
>template <> struct __make_unsigned<unsigned int, true> {typedef unsigned int type;};
>template <> struct __make_unsigned< signed long, true> {typedef unsigned long type;};
>template <> struct __make_unsigned<unsigned long, true> {typedef unsigned long type;};
>template <> struct __make_unsigned< signed long long, true> {typedef unsigned long long type;};
>template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
>
>
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) make_unsigned
>{
>    typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
>};
>template <class ..._Tp> struct common_type;
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) common_type<_Tp>
>{
>    typedef typename decay<_Tp>::type type;
>};
>
>template <class _Tp, class _Up>
>struct __attribute__ ((__visibility__("default"))) common_type<_Tp, _Up>
>{
>private:
>    static _Tp&& __t();
>    static _Up&& __u();
>    static bool __f();
>public:
>    typedef typename decay<decltype(__f() ? __t() : __u())>::type type;
>};
>
>template <class _Tp, class _Up, class ..._Vp>
>struct __attribute__ ((__visibility__("default"))) common_type<_Tp, _Up, _Vp...>
>{
>    typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
>};
>template<typename, typename _Tp> struct __select_2nd { typedef _Tp type; };
>
>template <class _Tp, class _Arg>
>typename __select_2nd<decltype((std::__1::declval<_Tp>() = std::__1::declval<_Arg>())), true_type>::type
>
>__is_assignable_test(_Tp&&, _Arg&&);
>
>
>
>
>template <class _Arg>
>false_type
>
>__is_assignable_test(__any, _Arg&&);
>
>
>
>
>template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
>struct __is_assignable_imp
>    : public common_type
>        <
>            decltype(__is_assignable_test(declval<_Tp>(), declval<_Arg>()))
>        >::type {};
>
>template <class _Tp, class _Arg>
>struct __is_assignable_imp<_Tp, _Arg, true>
>    : public false_type
>{
>};
>
>template <class _Tp, class _Arg>
>struct is_assignable
>    : public __is_assignable_imp<_Tp, _Arg> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_copy_assignable
>    : public is_assignable<typename add_lvalue_reference<_Tp>::type,
>                     const typename add_lvalue_reference<_Tp>::type> {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_move_assignable
>
>    : public is_assignable<typename add_lvalue_reference<_Tp>::type,
>                     const typename add_rvalue_reference<_Tp>::type> {};
>
>
>
>
>
>
>template <class _Tp>
>struct __destructible_test
>{
>    _Tp __t;
>};
>
>template <class _Tp>
>decltype((std::__1::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
>
>__is_destructible_test(_Tp&&);
>
>
>
>
>false_type
>__is_destructible_test(__any);
>
>template <class _Tp, bool = is_void<_Tp>::value || is_abstract<_Tp>::value
>                                                || is_function<_Tp>::value>
>struct __destructible_imp
>    : public common_type
>        <
>            decltype(__is_destructible_test(declval<_Tp>()))
>        >::type {};
>
>template <class _Tp>
>struct __destructible_imp<_Tp, true>
>    : public false_type {};
>
>template <class _Tp>
>struct is_destructible
>    : public __destructible_imp<_Tp> {};
>
>template <class _Tp>
>struct is_destructible<_Tp[]>
>    : public false_type {};
>
>
>
>
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename remove_reference<_Tp>::type&&
>move(_Tp&& __t) throw()
>{
>    typedef typename remove_reference<_Tp>::type _Up;
>    return static_cast<_Up&&>(__t);
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp&&
>forward(typename std::remove_reference<_Tp>::type& __t) throw()
>{
>    return static_cast<_Tp&&>(__t);
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp&&
>forward(typename std::remove_reference<_Tp>::type&& __t) throw()
>{
>    static_assert(!std::is_lvalue_reference<_Tp>::value,
>                  "Can not forward an rvalue as an lvalue.");
>    return static_cast<_Tp&&>(__t);
>}
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename decay<_Tp>::type
>__decay_copy(_Tp&& __t)
>{
>    return std::__1::forward<_Tp>(__t);
>}
>template <class _Rp, class _Class, class ..._Param>
>struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>
>{
>    typedef _Class _ClassType;
>    typedef _Rp _ReturnType;
>    typedef _Rp (_FnType) (_Param...);
>};
>
>template <class _Rp, class _Class, class ..._Param>
>struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true, false>
>{
>    typedef _Class const _ClassType;
>    typedef _Rp _ReturnType;
>    typedef _Rp (_FnType) (_Param...);
>};
>
>template <class _Rp, class _Class, class ..._Param>
>struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true, false>
>{
>    typedef _Class volatile _ClassType;
>    typedef _Rp _ReturnType;
>    typedef _Rp (_FnType) (_Param...);
>};
>
>template <class _Rp, class _Class, class ..._Param>
>struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile, true, false>
>{
>    typedef _Class const volatile _ClassType;
>    typedef _Rp _ReturnType;
>    typedef _Rp (_FnType) (_Param...);
>};
>template <class _Rp, class _Class>
>struct __member_pointer_traits_imp<_Rp _Class::*, false, true>
>{
>    typedef _Class _ClassType;
>    typedef _Rp _ReturnType;
>};
>
>template <class _MP>
>struct __member_pointer_traits
>    : public __member_pointer_traits_imp<typename remove_cv<_MP>::type,
>                    is_member_function_pointer<_MP>::value,
>                    is_member_object_pointer<_MP>::value>
>{
>
>
>
>};
>
>
>
>template <class _Callable> class result_of;
>namespace __is_construct
>{
>struct __nat {};
>}
>template <class _Tp, class ..._Args>
>typename __select_2nd<decltype(std::__1::move(_Tp(std::__1::declval<_Args>()...))), true_type>::type
>__is_constructible_test(_Tp&&, _Args&& ...);
>
>template <class ..._Args>
>false_type
>__is_constructible_test(__any, _Args&& ...);
>
>template <bool, class _Tp, class... _Args>
>struct __libcpp_is_constructible
>    : public common_type
>             <
>                 decltype(__is_constructible_test(declval<_Tp>(), declval<_Args>()...))
>             >::type
>    {};
>
>
>
>template <class _Rp, class... _A1, class... _A2>
>struct __libcpp_is_constructible<false, _Rp(_A1...), _A2...>
>    : public false_type
>    {};
>
>
>
>
>
>template <class _Tp>
>struct __libcpp_is_constructible<true, _Tp>
>    : public is_scalar<_Tp>
>    {};
>
>
>
>
>template <class _Tp>
>struct __is_constructible_ref
>{
>    true_type static __lxx(_Tp);
>    false_type static __lxx(...);
>};
>
>template <class _Tp, class _A0>
>struct __libcpp_is_constructible<true, _Tp, _A0>
>    : public common_type
>             <
>                 decltype(__is_constructible_ref<_Tp>::__lxx(declval<_A0>()))
>             >::type
>    {};
>
>
>
>template <class _Tp, class _A0, class ..._Args>
>struct __libcpp_is_constructible<true, _Tp, _A0, _Args...>
>    : public false_type
>    {};
>
>
>
>template <bool, class _Tp, class... _Args>
>struct __is_constructible_void_check
>    : public __libcpp_is_constructible<is_scalar<_Tp>::value || is_reference<_Tp>::value,
>                                _Tp, _Args...>
>    {};
>
>
>
>template <class _Tp, class... _Args>
>struct __is_constructible_void_check<true, _Tp, _Args...>
>    : public false_type
>    {};
>
>template <class ..._Args> struct __contains_void;
>
>template <> struct __contains_void<> : false_type {};
>
>template <class _A0, class ..._Args>
>struct __contains_void<_A0, _Args...>
>{
>    static const bool value = is_void<_A0>::value ||
>                              __contains_void<_Args...>::value;
>};
>
>
>
>template <class _Tp, class... _Args>
>struct __attribute__ ((__visibility__("default"))) is_constructible
>    : public __is_constructible_void_check<__contains_void<_Tp, _Args...>::value
>                                        || is_abstract<_Tp>::value,
>                                           _Tp, _Args...>
>    {};
>
>
>
>
>template <class _Ap, size_t _Np>
>struct __libcpp_is_constructible<false, _Ap[_Np]>
>    : public is_constructible<typename remove_all_extents<_Ap>::type>
>    {};
>
>
>
>template <class _Ap, size_t _Np, class ..._Args>
>struct __libcpp_is_constructible<false, _Ap[_Np], _Args...>
>    : public false_type
>    {};
>
>
>
>template <class _Ap, class ..._Args>
>struct __libcpp_is_constructible<false, _Ap[], _Args...>
>    : public false_type
>    {};
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_default_constructible
>    : public is_constructible<_Tp>
>    {};
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_copy_constructible
>    : public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
>    {};
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_move_constructible
>
>    : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
>
>
>
>    {};
>template <class _Tp, class... _Args>
>struct __attribute__ ((__visibility__("default"))) is_trivially_constructible
>    : false_type
>{
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_trivially_constructible<_Tp>
>
>    : integral_constant<bool, __has_trivial_constructor(_Tp)>
>
>
>
>{
>};
>
>template <class _Tp>
>
>struct __attribute__ ((__visibility__("default"))) is_trivially_constructible<_Tp, _Tp&&>
>
>
>
>    : integral_constant<bool, is_scalar<_Tp>::value>
>{
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_trivially_constructible<_Tp, const _Tp&>
>    : integral_constant<bool, is_scalar<_Tp>::value>
>{
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_trivially_constructible<_Tp, _Tp&>
>    : integral_constant<bool, is_scalar<_Tp>::value>
>{
>};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivially_default_constructible
>    : public is_trivially_constructible<_Tp>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivially_copy_constructible
>    : public is_trivially_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivially_move_constructible
>
>    : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
>
>
>
>    {};
>template <class _Tp, class _Arg>
>struct is_trivially_assignable
>    : public false_type {};
>
>template <class _Tp>
>struct is_trivially_assignable<_Tp&, _Tp>
>    : integral_constant<bool, is_scalar<_Tp>::value> {};
>
>template <class _Tp>
>struct is_trivially_assignable<_Tp&, _Tp&>
>    : integral_constant<bool, is_scalar<_Tp>::value> {};
>
>template <class _Tp>
>struct is_trivially_assignable<_Tp&, const _Tp&>
>    : integral_constant<bool, is_scalar<_Tp>::value> {};
>
>
>
>template <class _Tp>
>struct is_trivially_assignable<_Tp&, _Tp&&>
>    : integral_constant<bool, is_scalar<_Tp>::value> {};
>
>
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivially_copy_assignable
>    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
>                               const typename add_lvalue_reference<_Tp>::type>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivially_move_assignable
>    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
>
>                                     typename add_rvalue_reference<_Tp>::type>
>
>
>
>    {};
>
>
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivially_destructible
>    : public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
>template <bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;
>
>template <class _Tp, class... _Args>
>struct __libcpp_is_nothrow_constructible<true, _Tp, _Args...>
>    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
>{
>};
>
>template <class _Tp, class... _Args>
>struct __libcpp_is_nothrow_constructible<false, _Tp, _Args...>
>    : public false_type
>{
>};
>
>template <class _Tp, class... _Args>
>struct __attribute__ ((__visibility__("default"))) is_nothrow_constructible
>    : __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, _Tp, _Args...>
>{
>};
>
>template <class _Tp, size_t _Ns>
>struct __attribute__ ((__visibility__("default"))) is_nothrow_constructible<_Tp[_Ns]>
>    : __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, _Tp>
>{
>};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_nothrow_default_constructible
>    : public is_nothrow_constructible<_Tp>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_nothrow_copy_constructible
>    : public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_nothrow_move_constructible
>
>    : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
>
>
>
>    {};
>
>
>
>
>
>template <bool, class _Tp, class _Arg> struct __libcpp_is_nothrow_assignable;
>
>template <class _Tp, class _Arg>
>struct __libcpp_is_nothrow_assignable<false, _Tp, _Arg>
>    : public false_type
>{
>};
>
>template <class _Tp, class _Arg>
>struct __libcpp_is_nothrow_assignable<true, _Tp, _Arg>
>    : public integral_constant<bool, noexcept(std::__1::declval<_Tp>() = std::__1::declval<_Arg>()) >
>{
>};
>
>template <class _Tp, class _Arg>
>struct __attribute__ ((__visibility__("default"))) is_nothrow_assignable
>    : public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
>{
>};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_nothrow_copy_assignable
>    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
>                               const typename add_lvalue_reference<_Tp>::type>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_nothrow_move_assignable
>    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
>
>                                     typename add_rvalue_reference<_Tp>::type>
>
>
>
>    {};
>
>
>
>
>
>template <bool, class _Tp> struct __libcpp_is_nothrow_destructible;
>
>template <class _Tp>
>struct __libcpp_is_nothrow_destructible<false, _Tp>
>    : public false_type
>{
>};
>
>template <class _Tp>
>struct __libcpp_is_nothrow_destructible<true, _Tp>
>    : public integral_constant<bool, noexcept(std::__1::declval<_Tp>().~_Tp()) >
>{
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_nothrow_destructible
>    : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
>{
>};
>
>template <class _Tp, size_t _Ns>
>struct __attribute__ ((__visibility__("default"))) is_nothrow_destructible<_Tp[_Ns]>
>    : public is_nothrow_destructible<_Tp>
>{
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_nothrow_destructible<_Tp&>
>    : public true_type
>{
>};
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) is_nothrow_destructible<_Tp&&>
>    : public true_type
>{
>};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_pod
>    : public integral_constant<bool, __is_pod(_Tp)> {};
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_literal_type
>
>    : public integral_constant<bool, __is_literal_type(_Tp)>
>
>
>
>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_standard_layout
>
>    : public integral_constant<bool, __is_standard_layout(_Tp)>
>
>
>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivially_copyable
>
>
>
>    : integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>
>
>    {};
>
>
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) is_trivial
>
>    : public integral_constant<bool, __is_trivial(_Tp)>
>
>
>
>
>    {};
>
>
>
>
>
>template <class ..._Tp> struct __check_complete;
>
>template <>
>struct __check_complete<>
>{
>};
>
>template <class _Hp, class _T0, class ..._Tp>
>struct __check_complete<_Hp, _T0, _Tp...>
>    : private __check_complete<_Hp>,
>      private __check_complete<_T0, _Tp...>
>{
>};
>
>template <class _Hp>
>struct __check_complete<_Hp, _Hp>
>    : private __check_complete<_Hp>
>{
>};
>
>template <class _Tp>
>struct __check_complete<_Tp>
>{
>    static_assert(sizeof(_Tp) > 0, "Type must be complete.");
>};
>
>template <class _Tp>
>struct __check_complete<_Tp&>
>    : private __check_complete<_Tp>
>{
>};
>
>template <class _Tp>
>struct __check_complete<_Tp&&>
>    : private __check_complete<_Tp>
>{
>};
>
>template <class _Rp, class ..._Param>
>struct __check_complete<_Rp (*)(_Param...)>
>    : private __check_complete<_Rp>
>{
>};
>
>template <class ..._Param>
>struct __check_complete<void (*)(_Param...)>
>{
>};
>
>template <class _Rp, class ..._Param>
>struct __check_complete<_Rp (_Param...)>
>    : private __check_complete<_Rp>
>{
>};
>
>template <class ..._Param>
>struct __check_complete<void (_Param...)>
>{
>};
>
>template <class _Rp, class _Class, class ..._Param>
>struct __check_complete<_Rp (_Class::*)(_Param...)>
>    : private __check_complete<_Class>
>{
>};
>
>template <class _Rp, class _Class, class ..._Param>
>struct __check_complete<_Rp (_Class::*)(_Param...) const>
>    : private __check_complete<_Class>
>{
>};
>
>template <class _Rp, class _Class, class ..._Param>
>struct __check_complete<_Rp (_Class::*)(_Param...) volatile>
>    : private __check_complete<_Class>
>{
>};
>
>template <class _Rp, class _Class, class ..._Param>
>struct __check_complete<_Rp (_Class::*)(_Param...) const volatile>
>    : private __check_complete<_Class>
>{
>};
>template <class _Rp, class _Class>
>struct __check_complete<_Rp _Class::*>
>    : private __check_complete<_Class>
>{
>};
>
>
>
>
>
>template <class ..._Args>
>auto
>__invoke(__any, _Args&& ...__args)
>    -> __nat;
>
>
>
>template <class _Fp, class _A0, class ..._Args,
>            class = typename enable_if
>            <
>                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
>                is_base_of<typename remove_reference<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType>::type,
>                           typename remove_reference<_A0>::type>::value
>            >::type
>         >
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
>    -> decltype((std::__1::forward<_A0>(__a0).*__f)(std::__1::forward<_Args>(__args)...));
>
>template <class _Fp, class _A0, class ..._Args,
>            class = typename enable_if
>            <
>                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
>                !is_base_of<typename remove_reference<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType>::type,
>                           typename remove_reference<_A0>::type>::value
>            >::type
>         >
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
>    -> decltype(((*std::__1::forward<_A0>(__a0)).*__f)(std::__1::forward<_Args>(__args)...));
>
>
>
>template <class _Fp, class _A0,
>            class = typename enable_if
>            <
>                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
>                is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
>                           typename remove_reference<_A0>::type>::value
>            >::type
>         >
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0)
>    -> decltype(std::__1::forward<_A0>(__a0).*__f);
>
>template <class _Fp, class _A0,
>            class = typename enable_if
>            <
>                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
>                !is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
>                           typename remove_reference<_A0>::type>::value
>            >::type
>         >
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0)
>    -> decltype((*std::__1::forward<_A0>(__a0)).*__f);
>
>
>
>template <class _Fp, class ..._Args>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _Args&& ...__args)
>    -> decltype(std::__1::forward<_Fp>(__f)(std::__1::forward<_Args>(__args)...));
>
>
>
>template <class _Fp, class ..._Args>
>struct __invokable_imp
>    : private __check_complete<_Fp>
>{
>    typedef decltype(
>            __invoke(std::__1::declval<_Fp>(), std::__1::declval<_Args>()...)
>                    ) type;
>    static const bool value = !is_same<type, __nat>::value;
>};
>
>template <class _Fp, class ..._Args>
>struct __invokable
>    : public integral_constant<bool,
>          __invokable_imp<_Fp, _Args...>::value>
>{
>};
>
>
>
>template <bool _Invokable, class _Fp, class ..._Args>
>struct __invoke_of_imp
>{
>};
>
>template <class _Fp, class ..._Args>
>struct __invoke_of_imp<true, _Fp, _Args...>
>{
>    typedef typename __invokable_imp<_Fp, _Args...>::type type;
>};
>
>template <class _Fp, class ..._Args>
>struct __invoke_of
>    : public __invoke_of_imp<__invokable<_Fp, _Args...>::value, _Fp, _Args...>
>{
>};
>
>template <class _Fp, class ..._Args>
>class __attribute__ ((__visibility__("default"))) result_of<_Fp(_Args...)>
>    : public __invoke_of<_Fp, _Args...>
>{
>};
>
>
>
>
>
>
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>
>typename enable_if
><
>    is_move_constructible<_Tp>::value &&
>    is_move_assignable<_Tp>::value
>>::type
>
>
>
>swap(_Tp& __x, _Tp& __y)
>
>{
>    _Tp __t(std::__1::move(__x));
>    __x = std::__1::move(__y);
>    __y = std::__1::move(__t);
>}
>
>template <class _ForwardIterator1, class _ForwardIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
>
>              
>
>{
>    swap(*__a, *__b);
>}
>
>
>
>namespace __detail
>{
>
>using std::__1::swap;
>__nat swap(__any, __any);
>
>template <class _Tp>
>struct __swappable
>{
>    typedef decltype(swap(std::__1::declval<_Tp&>(), std::__1::declval<_Tp&>())) type;
>    static const bool value = !is_same<type, __nat>::value;
>};
>
>}
>
>template <class _Tp>
>struct __is_swappable
>    : public integral_constant<bool, __detail::__swappable<_Tp>::value>
>{
>};
>
>
>
>template <bool, class _Tp>
>struct __is_nothrow_swappable_imp
>    : public integral_constant<bool, noexcept(swap(std::__1::declval<_Tp&>(),
>                                                   std::__1::declval<_Tp&>()))>
>{
>};
>
>template <class _Tp>
>struct __is_nothrow_swappable_imp<false, _Tp>
>    : public false_type
>{
>};
>
>template <class _Tp>
>struct __is_nothrow_swappable
>    : public __is_nothrow_swappable_imp<__is_swappable<_Tp>::value, _Tp>
>{
>};
>template <class _Tp>
>struct underlying_type
>{
>    typedef __underlying_type(_Tp) type;
>};
>template <class _Tp>
>struct __has_operator_addressof_imp
>{
>    template <class>
>        static auto __test(__any) -> false_type;
>    template <class _Up>
>        static auto __test(_Up* __u)
>            -> typename __select_2nd<decltype(__u->operator&()), true_type>::type;
>
>    static const bool value = decltype(__test<_Tp>(nullptr))::value;
>};
>
>template <class _Tp>
>struct __has_operator_addressof
>    : public integral_constant<bool, __has_operator_addressof_imp<_Tp>::value>
>{};
>
>
>
>} }
>       
>
>
>namespace std
>{
>
>class __attribute__ ((__visibility__("default"))) exception
>{
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception() throw() {}
>    virtual ~exception() throw();
>    virtual const char* what() const throw();
>};
>
>class __attribute__ ((__visibility__("default"))) bad_exception
>    : public exception
>{
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) bad_exception() throw() {}
>    virtual ~bad_exception() throw();
>    virtual const char* what() const throw();
>};
>
>typedef void (*unexpected_handler)();
>__attribute__ ((__visibility__("default"))) unexpected_handler set_unexpected(unexpected_handler) throw();
>__attribute__ ((__visibility__("default"))) unexpected_handler get_unexpected() throw();
>__attribute__((noreturn)) __attribute__ ((__visibility__("default"))) void unexpected();
>
>typedef void (*terminate_handler)();
>__attribute__ ((__visibility__("default"))) terminate_handler set_terminate(terminate_handler) throw();
>__attribute__ ((__visibility__("default"))) terminate_handler get_terminate() throw();
>
>__attribute__((noreturn)) __attribute__ ((__visibility__("default"))) void terminate() throw();
>
>
>
>
>__attribute__ ((__visibility__("default"))) bool uncaught_exception() throw();
>
>class __attribute__ ((__visibility__("default"))) exception_ptr;
>
>__attribute__ ((__visibility__("default"))) exception_ptr current_exception() throw();
>__attribute__((noreturn)) __attribute__ ((__visibility__("default"))) void rethrow_exception(exception_ptr);
>
>class __attribute__ ((__visibility__("default"))) exception_ptr
>{
>    void* __ptr_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception_ptr() throw() : __ptr_() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception_ptr(nullptr_t) throw() : __ptr_() {}
>    exception_ptr(const exception_ptr&) throw();
>    exception_ptr& operator=(const exception_ptr&) throw();
>    ~exception_ptr() throw();
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>   
>        operator bool() const throw() {return __ptr_ != nullptr;}
>
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator==(const exception_ptr& __x, const exception_ptr& __y) throw()
>        {return __x.__ptr_ == __y.__ptr_;}
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator!=(const exception_ptr& __x, const exception_ptr& __y) throw()
>        {return !(__x == __y);}
>
>    friend __attribute__ ((__visibility__("default"))) exception_ptr current_exception() throw();
>    friend __attribute__ ((__visibility__("default"))) void rethrow_exception(exception_ptr);
>};
>
>template<class _Ep>
>exception_ptr
>make_exception_ptr(_Ep __e) throw()
>{
>
>    try
>    {
>        throw __e;
>    }
>    catch (...)
>    {
>        return current_exception();
>    }
>
>}
>
>
>
>class __attribute__ ((__visibility__("default"))) nested_exception
>{
>    exception_ptr __ptr_;
>public:
>    nested_exception() throw();
>
>
>    virtual ~nested_exception() throw();
>
>
>    __attribute__((noreturn)) void rethrow_nested() const;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception_ptr nested_ptr() const throw() {return __ptr_;}
>};
>
>template <class _Tp>
>struct __nested
>    : public _Tp,
>      public nested_exception
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __nested(const _Tp& __t) : _Tp(__t) {}
>};
>
>template <class _Tp>
>__attribute__((noreturn))
>void
>
>throw_with_nested(_Tp&& __t, typename enable_if<
>                  is_class<typename remove_reference<_Tp>::type>::value &&
>                  !is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
>                                    >::type* = 0)
>
>
>
>
>
>{
>
>    throw __nested<typename remove_reference<_Tp>::type>(std::__1::forward<_Tp>(__t));
>
>}
>
>template <class _Tp>
>__attribute__((noreturn))
>void
>
>throw_with_nested(_Tp&& __t, typename enable_if<
>                  !is_class<typename remove_reference<_Tp>::type>::value ||
>                  is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
>                                    >::type* = 0)
>
>
>
>
>
>{
>
>    throw std::__1::forward<_Tp>(__t);
>
>}
>
>template <class _Ep>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>rethrow_if_nested(const _Ep& __e, typename enable_if<
>                                   is_polymorphic<_Ep>::value
>                                                   >::type* = 0)
>{
>    const nested_exception* __nep = dynamic_cast<const nested_exception*>(&__e);
>    if (__nep)
>        __nep->rethrow_nested();
>}
>
>template <class _Ep>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>rethrow_if_nested(const _Ep&, typename enable_if<
>                                   !is_polymorphic<_Ep>::value
>                                                   >::type* = 0)
>{
>}
>
>}
>
>       
>
>
>namespace std { namespace __1 {
>
>using::int8_t;
>using::int16_t;
>using::int32_t;
>using::int64_t;
>
>using::uint8_t;
>using::uint16_t;
>using::uint32_t;
>using::uint64_t;
>
>using::int_least8_t;
>using::int_least16_t;
>using::int_least32_t;
>using::int_least64_t;
>
>using::uint_least8_t;
>using::uint_least16_t;
>using::uint_least32_t;
>using::uint_least64_t;
>
>using::int_fast8_t;
>using::int_fast16_t;
>using::int_fast32_t;
>using::int_fast64_t;
>
>using::uint_fast8_t;
>using::uint_fast16_t;
>using::uint_fast32_t;
>using::uint_fast64_t;
>
>using::intptr_t;
>using::uintptr_t;
>
>using::intmax_t;
>using::uintmax_t;
>
>} }
>
>
>       
>
>
>namespace std
>{
>
>class __attribute__ ((__visibility__("default"))) type_info
>{
>    type_info& operator=(const type_info&);
>    type_info(const type_info&);
>protected:
>
>    const char* __type_name;
>
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit type_info(const char* __n)
>
>        : __type_name(__n) {}
>
>
>
>
>public:
>    virtual ~type_info();
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const char* name() const throw()
>
>        {return __type_name;}
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool before(const type_info& __arg) const throw()
>
>        {return __type_name < __arg.__type_name;}
>
>
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_t hash_code() const throw()
>
>        {return *reinterpret_cast<const size_t*>(&__type_name);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator==(const type_info& __arg) const throw()
>
>        {return __type_name == __arg.__type_name;}
>
>
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator!=(const type_info& __arg) const throw()
>        {return !operator==(__arg);}
>
>
>
>
>
>
>
>};
>
>class __attribute__ ((__visibility__("default"))) bad_cast
>    : public exception
>{
>public:
>    bad_cast() throw();
>    virtual ~bad_cast() throw();
>    virtual const char* what() const throw();
>};
>
>class __attribute__ ((__visibility__("default"))) bad_typeid
>    : public exception
>{
>public:
>    bad_typeid() throw();
>    virtual ~bad_typeid() throw();
>    virtual const char* what() const throw();
>};
>
>}
>
>
>       
>
>
>namespace std
>{
>
>class __attribute__ ((__visibility__("default"))) bad_alloc
>    : public exception
>{
>public:
>    bad_alloc() throw();
>    virtual ~bad_alloc() throw();
>    virtual const char* what() const throw();
>};
>
>class __attribute__ ((__visibility__("default"))) bad_array_new_length
>    : public bad_alloc
>{
>public:
>    bad_array_new_length() throw();
>    virtual ~bad_array_new_length() throw();
>    virtual const char* what() const throw();
>};
>__attribute__ ((__visibility__("default"))) void __throw_bad_alloc();
>
>struct __attribute__ ((__visibility__("default"))) nothrow_t {};
>extern __attribute__ ((__visibility__("default"))) const nothrow_t nothrow;
>typedef void (*new_handler)();
>__attribute__ ((__visibility__("default"))) new_handler set_new_handler(new_handler) throw();
>__attribute__ ((__visibility__("default"))) new_handler get_new_handler() throw();
>
>}
>
>
>
>
>
>
>
>__attribute__ ((__visibility__("default"))) void* operator new(std::size_t __sz)
>
>    throw(std::bad_alloc)
>
>;
>__attribute__ ((__visibility__("default"))) void* operator new(std::size_t __sz, const std::nothrow_t&) throw() __attribute__((__malloc__));
>__attribute__ ((__visibility__("default"))) void operator delete(void* __p) throw();
>__attribute__ ((__visibility__("default"))) void operator delete(void* __p, const std::nothrow_t&) throw();
>
>__attribute__ ((__visibility__("default"))) void* operator new[](std::size_t __sz)
>
>    throw(std::bad_alloc)
>
>;
>__attribute__ ((__visibility__("default"))) void* operator new[](std::size_t __sz, const std::nothrow_t&) throw() __attribute__((__malloc__));
>__attribute__ ((__visibility__("default"))) void operator delete[](void* __p) throw();
>__attribute__ ((__visibility__("default"))) void operator delete[](void* __p, const std::nothrow_t&) throw();
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void* operator new (std::size_t, void* __p) throw() {return __p;}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void* operator new[](std::size_t, void* __p) throw() {return __p;}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void operator delete (void*, void*) throw() {}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void operator delete[](void*, void*) throw() {}
>       
>namespace std { namespace __1 {
>
>template <class _Tp> class __attribute__ ((__visibility__("default"))) tuple_size;
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) tuple_size<const _Tp>
>    : public tuple_size<_Tp> {};
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) tuple_size<volatile _Tp>
>    : public tuple_size<_Tp> {};
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) tuple_size<const volatile _Tp>
>    : public tuple_size<_Tp> {};
>
>template <size_t _Ip, class _Tp> class __attribute__ ((__visibility__("default"))) tuple_element;
>
>template <size_t _Ip, class _Tp>
>class __attribute__ ((__visibility__("default"))) tuple_element<_Ip, const _Tp>
>{
>public:
>    typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
>};
>
>template <size_t _Ip, class _Tp>
>class __attribute__ ((__visibility__("default"))) tuple_element<_Ip, volatile _Tp>
>{
>public:
>    typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
>};
>
>template <size_t _Ip, class _Tp>
>class __attribute__ ((__visibility__("default"))) tuple_element<_Ip, const volatile _Tp>
>{
>public:
>    typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
>};
>
>template <class ..._Tp> class __attribute__ ((__visibility__("default"))) tuple;
>template <class _T1, class _T2> struct __attribute__ ((__visibility__("default"))) pair;
>template <class _Tp, size_t _Size> struct __attribute__ ((__visibility__("default"))) array;
>
>template <class _Tp> struct __tuple_like : false_type {};
>
>template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
>template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
>template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
>
>template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
>template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
>template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
>
>template <size_t _Ip, class ..._Tp>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, tuple<_Tp...> >::type&
>get(tuple<_Tp...>&) throw();
>
>template <size_t _Ip, class ..._Tp>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>const typename tuple_element<_Ip, tuple<_Tp...> >::type&
>get(const tuple<_Tp...>&) throw();
>
>template <size_t _Ip, class ..._Tp>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, tuple<_Tp...> >::type&&
>get(tuple<_Tp...>&&) throw();
>
>template <size_t _Ip, class _T1, class _T2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, pair<_T1, _T2> >::type&
>get(pair<_T1, _T2>&) throw();
>
>template <size_t _Ip, class _T1, class _T2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
>get(const pair<_T1, _T2>&) throw();
>
>template <size_t _Ip, class _T1, class _T2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
>get(pair<_T1, _T2>&&) throw();
>
>template <size_t _Ip, class _Tp, size_t _Size>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp&
>get(array<_Tp, _Size>&) throw();
>
>template <size_t _Ip, class _Tp, size_t _Size>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>const _Tp&
>get(const array<_Tp, _Size>&) throw();
>
>template <size_t _Ip, class _Tp, size_t _Size>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp&&
>get(array<_Tp, _Size>&&) throw();
>
>
>
>template <size_t...> struct __tuple_indices {};
>
>template <size_t _Sp, class _IntTuple, size_t _Ep>
>struct __make_indices_imp;
>
>template <size_t _Sp, size_t ..._Indices, size_t _Ep>
>struct __make_indices_imp<_Sp, __tuple_indices<_Indices...>, _Ep>
>{
>    typedef typename __make_indices_imp<_Sp+1, __tuple_indices<_Indices..., _Sp>, _Ep>::type type;
>};
>
>template <size_t _Ep, size_t ..._Indices>
>struct __make_indices_imp<_Ep, __tuple_indices<_Indices...>, _Ep>
>{
>    typedef __tuple_indices<_Indices...> type;
>};
>
>template <size_t _Ep, size_t _Sp = 0>
>struct __make_tuple_indices
>{
>    static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
>    typedef typename __make_indices_imp<_Sp, __tuple_indices<>, _Ep>::type type;
>};
>
>
>
>template <class ..._Tp> struct __tuple_types {};
>
>template <size_t _Ip>
>class __attribute__ ((__visibility__("default"))) tuple_element<_Ip, __tuple_types<> >
>{
>public:
>    static_assert(_Ip == 0, "tuple_element index out of range");
>    static_assert(_Ip != 0, "tuple_element index out of range");
>};
>
>template <class _Hp, class ..._Tp>
>class __attribute__ ((__visibility__("default"))) tuple_element<0, __tuple_types<_Hp, _Tp...> >
>{
>public:
>    typedef _Hp type;
>};
>
>template <size_t _Ip, class _Hp, class ..._Tp>
>class __attribute__ ((__visibility__("default"))) tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
>{
>public:
>    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
>};
>
>template <class ..._Tp>
>class __attribute__ ((__visibility__("default"))) tuple_size<__tuple_types<_Tp...> >
>    : public integral_constant<size_t, sizeof...(_Tp)>
>{
>};
>
>template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
>template <class _TupleTypes, class _Tp, size_t _Sp, size_t _Ep>
>struct __make_tuple_types_imp;
>
>template <class ..._Types, class _Tp, size_t _Sp, size_t _Ep>
>struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Sp, _Ep>
>{
>    typedef typename remove_reference<_Tp>::type _Tpr;
>    typedef typename __make_tuple_types_imp<__tuple_types<_Types...,
>                                            typename conditional<is_lvalue_reference<_Tp>::value,
>                                                typename tuple_element<_Sp, _Tpr>::type&,
>                                                typename tuple_element<_Sp, _Tpr>::type>::type>,
>                                            _Tp, _Sp+1, _Ep>::type type;
>};
>
>template <class ..._Types, class _Tp, size_t _Ep>
>struct __make_tuple_types_imp<__tuple_types<_Types...>, _Tp, _Ep, _Ep>
>{
>    typedef __tuple_types<_Types...> type;
>};
>
>template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value, size_t _Sp = 0>
>struct __make_tuple_types
>{
>    static_assert(_Sp <= _Ep, "__make_tuple_types input error");
>    typedef typename __make_tuple_types_imp<__tuple_types<>, _Tp, _Sp, _Ep>::type type;
>};
>
>
>
>template <bool, class _Tp, class _Up>
>struct __tuple_convertible_imp : public false_type {};
>
>template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
>struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
>    : public integral_constant<bool,
>                               is_convertible<_Tp0, _Up0>::value &&
>                               __tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
>
>template <>
>struct __tuple_convertible_imp<true, __tuple_types<>, __tuple_types<> >
>    : public true_type {};
>
>template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
>                                bool = __tuple_like<_Up>::value>
>struct __tuple_convertible
>    : public false_type {};
>
>template <class _Tp, class _Up>
>struct __tuple_convertible<_Tp, _Up, true, true>
>    : public __tuple_convertible_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
>                                     tuple_size<_Up>::value,
>             typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
>{};
>
>
>
>template <bool, class _Tp, class _Up>
>struct __tuple_constructible_imp : public false_type {};
>
>template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
>struct __tuple_constructible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
>    : public integral_constant<bool,
>                               is_constructible<_Up0, _Tp0>::value &&
>                               __tuple_constructible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
>
>template <>
>struct __tuple_constructible_imp<true, __tuple_types<>, __tuple_types<> >
>    : public true_type {};
>
>template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
>                                bool = __tuple_like<_Up>::value>
>struct __tuple_constructible
>    : public false_type {};
>
>template <class _Tp, class _Up>
>struct __tuple_constructible<_Tp, _Up, true, true>
>    : public __tuple_constructible_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
>                                     tuple_size<_Up>::value,
>             typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
>{};
>
>
>
>template <bool, class _Tp, class _Up>
>struct __tuple_assignable_imp : public false_type {};
>
>template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
>struct __tuple_assignable_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
>    : public integral_constant<bool,
>                               is_assignable<_Up0&, _Tp0>::value &&
>                               __tuple_assignable_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
>
>template <>
>struct __tuple_assignable_imp<true, __tuple_types<>, __tuple_types<> >
>    : public true_type {};
>
>template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
>                                bool = __tuple_like<_Up>::value>
>struct __tuple_assignable
>    : public false_type {};
>
>template <class _Tp, class _Up>
>struct __tuple_assignable<_Tp, _Up, true, true>
>    : public __tuple_assignable_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
>                                    tuple_size<_Up>::value,
>             typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
>{};
>
>} }
>
>
>
>       
>
>
>namespace std { namespace __1 {
>
>namespace rel_ops
>{
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const _Tp& __x, const _Tp& __y)
>{
>    return !(__x == __y);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator> (const _Tp& __x, const _Tp& __y)
>{
>    return __y < __x;
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const _Tp& __x, const _Tp& __y)
>{
>    return !(__y < __x);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const _Tp& __x, const _Tp& __y)
>{
>    return !(__x < __y);
>}
>
>}
>
>
>
>template <class _ForwardIterator1, class _ForwardIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator2
>swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
>{
>    for(; __first1 != __last1; ++__first1, ++__first2)
>        swap(*__first1, *__first2);
>    return __first2;
>}
>
>template<class _Tp, size_t _Np>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np])
>{
>    std::__1::swap_ranges(__a, __a + _Np, __b);
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>
>typename conditional
><
>    !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
>    const _Tp&,
>    _Tp&&
>>::type
>
>
>
>move_if_noexcept(_Tp& __x) throw()
>{
>    return std::__1::move(__x);
>}
>
>struct __attribute__ ((__visibility__("default"))) piecewise_construct_t { };
>
>
>
>constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
>
>
>template <class _T1, class _T2>
>struct __attribute__ ((__visibility__("default"))) pair
>{
>    typedef _T1 first_type;
>    typedef _T2 second_type;
>
>    _T1 first;
>    _T2 second;
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr pair() : first(), second() {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pair(const _T1& __x, const _T2& __y)
>        : first(__x), second(__y) {}
>
>    template<class _U1, class _U2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        pair(const pair<_U1, _U2>& __p
>
>                 ,typename enable_if<is_convertible<const _U1&, _T1>::value &&
>                                    is_convertible<const _U2&, _T2>::value>::type* = 0
>
>                                      )
>            : first(__p.first), second(__p.second) {}
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pair(const pair& __p) = default;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pair& operator=(const pair& __p)
>       
>
>    {
>        first = __p.first;
>        second = __p.second;
>        return *this;
>    }
>
>
>
>    template <class _U1, class _U2,
>              class = typename enable_if<is_convertible<_U1, first_type>::value &&
>                                         is_convertible<_U2, second_type>::value>::type>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        pair(_U1&& __u1, _U2&& __u2)
>            : first(std::__1::forward<_U1>(__u1)),
>              second(std::__1::forward<_U2>(__u2))
>            {}
>
>    template<class _U1, class _U2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        pair(pair<_U1, _U2>&& __p,
>                 typename enable_if<is_convertible<_U1, _T1>::value &&
>                                    is_convertible<_U2, _T2>::value>::type* = 0)
>            : first(std::__1::forward<_U1>(__p.first)),
>              second(std::__1::forward<_U2>(__p.second)) {}
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pair(pair&& __p) = default;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pair&
>    operator=(pair&& __p)
>
>    {
>        first = std::__1::forward<first_type>(__p.first);
>        second = std::__1::forward<second_type>(__p.second);
>        return *this;
>    }
>
>
>
>    template<class _Tuple,
>             class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        pair(_Tuple&& __p)
>            : first(std::__1::forward<typename tuple_element<0,
>                                  typename __make_tuple_types<_Tuple>::type>::type>(get<0>(__p))),
>              second(std::__1::forward<typename tuple_element<1,
>                                   typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
>            {}
>
>
>
>    template <class... _Args1, class... _Args2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
>                                    tuple<_Args2...> __second_args)
>            : pair(__pc, __first_args, __second_args,
>                   typename __make_tuple_indices<sizeof...(_Args1)>::type(),
>                   typename __make_tuple_indices<sizeof...(_Args2) >::type())
>            {}
>
>    template <class _Tuple,
>              class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        pair&
>        operator=(_Tuple&& __p)
>        {
>            typedef typename __make_tuple_types<_Tuple>::type _TupleRef;
>            typedef typename tuple_element<0, _TupleRef>::type _U0;
>            typedef typename tuple_element<1, _TupleRef>::type _U1;
>            first = std::__1::forward<_U0>(std::__1::get<0>(__p));
>            second = std::__1::forward<_U1>(std::__1::get<1>(__p));
>            return *this;
>        }
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void
>    swap(pair& __p)
>
>    {
>        std::__1::iter_swap(&first, &__p.first);
>        std::__1::iter_swap(&second, &__p.second);
>    }
>private:
>
>
>    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        pair(piecewise_construct_t,
>             tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
>             __tuple_indices<_I1...>, __tuple_indices<_I2...>);
>
>};
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
>{
>    return __x.first == __y.first && __x.second == __y.second;
>}
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
>{
>    return !(__x == __y);
>}
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
>{
>    return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
>}
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
>{
>    return __y < __x;
>}
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
>{
>    return !(__x < __y);
>}
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
>{
>    return !(__y < __x);
>}
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    __is_swappable<_T1>::value &&
>    __is_swappable<_T2>::value,
>    void
>>::type
>swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
>                    
>
>{
>    __x.swap(__y);
>}
>
>
>
>template <class _Tp> class __attribute__ ((__visibility__("default"))) reference_wrapper;
>
>template <class _Tp>
>struct __make_pair_return_impl
>{
>    typedef _Tp type;
>};
>
>template <class _Tp>
>struct __make_pair_return_impl<reference_wrapper<_Tp>>
>{
>    typedef _Tp& type;
>};
>
>template <class _Tp>
>struct __make_pair_return
>{
>    typedef typename __make_pair_return_impl<typename decay<_Tp>::type>::type type;
>};
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
>make_pair(_T1&& __t1, _T2&& __t2)
>{
>    return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
>               (std::__1::forward<_T1>(__t1), std::__1::forward<_T2>(__t2));
>}
>template <class _T1, class _T2>
>  class __attribute__ ((__visibility__("default"))) tuple_size<pair<_T1, _T2> >
>    : public integral_constant<size_t, 2> {};
>
>template <class _T1, class _T2>
>  class __attribute__ ((__visibility__("default"))) tuple_size<const pair<_T1, _T2> >
>    : public integral_constant<size_t, 2> {};
>
>template <class _T1, class _T2>
>class __attribute__ ((__visibility__("default"))) tuple_element<0, pair<_T1, _T2> >
>{
>public:
>    typedef _T1 type;
>};
>
>template <class _T1, class _T2>
>class __attribute__ ((__visibility__("default"))) tuple_element<1, pair<_T1, _T2> >
>{
>public:
>    typedef _T2 type;
>};
>
>template <class _T1, class _T2>
>class __attribute__ ((__visibility__("default"))) tuple_element<0, const pair<_T1, _T2> >
>{
>public:
>    typedef const _T1 type;
>};
>
>template <class _T1, class _T2>
>class __attribute__ ((__visibility__("default"))) tuple_element<1, const pair<_T1, _T2> >
>{
>public:
>    typedef const _T2 type;
>};
>
>template <size_t _Ip> struct __get_pair;
>
>template <>
>struct __get_pair<0>
>{
>    template <class _T1, class _T2>
>    static
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    _T1&
>    get(pair<_T1, _T2>& __p) throw() {return __p.first;}
>
>    template <class _T1, class _T2>
>    static
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const _T1&
>    get(const pair<_T1, _T2>& __p) throw() {return __p.first;}
>
>
>
>    template <class _T1, class _T2>
>    static
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    _T1&&
>    get(pair<_T1, _T2>&& __p) throw() {return std::__1::forward<_T1>(__p.first);}
>
>
>};
>
>template <>
>struct __get_pair<1>
>{
>    template <class _T1, class _T2>
>    static
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    _T2&
>    get(pair<_T1, _T2>& __p) throw() {return __p.second;}
>
>    template <class _T1, class _T2>
>    static
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const _T2&
>    get(const pair<_T1, _T2>& __p) throw() {return __p.second;}
>
>
>
>    template <class _T1, class _T2>
>    static
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    _T2&&
>    get(pair<_T1, _T2>&& __p) throw() {return std::__1::forward<_T2>(__p.second);}
>
>
>};
>
>template <size_t _Ip, class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, pair<_T1, _T2> >::type&
>get(pair<_T1, _T2>& __p) throw()
>{
>    return __get_pair<_Ip>::get(__p);
>}
>
>template <size_t _Ip, class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
>get(const pair<_T1, _T2>& __p) throw()
>{
>    return __get_pair<_Ip>::get(__p);
>}
>
>
>
>template <size_t _Ip, class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
>get(pair<_T1, _T2>&& __p) throw()
>{
>    return __get_pair<_Ip>::get(std::__1::move(__p));
>}
>} }
>       
>
>
>
>
>
>namespace std { namespace __1 {
>
>enum float_round_style
>{
>    round_indeterminate = -1,
>    round_toward_zero = 0,
>    round_to_nearest = 1,
>    round_toward_infinity = 2,
>    round_toward_neg_infinity = 3
>};
>
>enum float_denorm_style
>{
>    denorm_indeterminate = -1,
>    denorm_absent = 0,
>    denorm_present = 1
>};
>
>template <class _Tp, bool = is_arithmetic<_Tp>::value>
>class __libcpp_numeric_limits
>{
>protected:
>    typedef _Tp type;
>
>    static constexpr const bool is_specialized = false;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return type();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return type();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return type();}
>
>    static constexpr const int digits = 0;
>    static constexpr const int digits10 = 0;
>    static constexpr const int max_digits10 = 0;
>    static constexpr const bool is_signed = false;
>    static constexpr const bool is_integer = false;
>    static constexpr const bool is_exact = false;
>    static constexpr const int radix = 0;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return type();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return type();}
>
>    static constexpr const int min_exponent = 0;
>    static constexpr const int min_exponent10 = 0;
>    static constexpr const int max_exponent = 0;
>    static constexpr const int max_exponent10 = 0;
>
>    static constexpr const bool has_infinity = false;
>    static constexpr const bool has_quiet_NaN = false;
>    static constexpr const bool has_signaling_NaN = false;
>    static constexpr const float_denorm_style has_denorm = denorm_absent;
>    static constexpr const bool has_denorm_loss = false;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return type();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return type();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return type();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return type();}
>
>    static constexpr const bool is_iec559 = false;
>    static constexpr const bool is_bounded = false;
>    static constexpr const bool is_modulo = false;
>
>    static constexpr const bool traps = false;
>    static constexpr const bool tinyness_before = false;
>    static constexpr const float_round_style round_style = round_toward_zero;
>};
>
>template <class _Tp, int digits, bool is_signed>
>struct __libcpp_compute_min
>{
>    static constexpr const _Tp value = _Tp(_Tp(1) << digits);
>};
>
>template <class _Tp, int digits>
>struct __libcpp_compute_min<_Tp, digits, false>
>{
>    static constexpr const _Tp value = _Tp(0);
>};
>
>template <class _Tp>
>class __libcpp_numeric_limits<_Tp, true>
>{
>protected:
>    typedef _Tp type;
>
>    static constexpr const bool is_specialized = true;
>
>    static constexpr const bool is_signed = type(-1) < type(0);
>    static constexpr const int digits = static_cast<int>(sizeof(type) * 8 - is_signed);
>    static constexpr const int digits10 = digits * 3 / 10;
>    static constexpr const int max_digits10 = 0;
>    static constexpr const type __min = __libcpp_compute_min<type, digits, is_signed>::value;
>    static constexpr const type __max = is_signed ? type(type(~0) ^ __min) : type(~0);
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return __min;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return __max;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return min();}
>
>    static constexpr const bool is_integer = true;
>    static constexpr const bool is_exact = true;
>    static constexpr const int radix = 2;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return type(0);}
>
>    static constexpr const int min_exponent = 0;
>    static constexpr const int min_exponent10 = 0;
>    static constexpr const int max_exponent = 0;
>    static constexpr const int max_exponent10 = 0;
>
>    static constexpr const bool has_infinity = false;
>    static constexpr const bool has_quiet_NaN = false;
>    static constexpr const bool has_signaling_NaN = false;
>    static constexpr const float_denorm_style has_denorm = denorm_absent;
>    static constexpr const bool has_denorm_loss = false;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return type(0);}
>
>    static constexpr const bool is_iec559 = false;
>    static constexpr const bool is_bounded = true;
>    static constexpr const bool is_modulo = true;
>
>
>
>
>    static constexpr const bool traps = false;
>
>    static constexpr const bool tinyness_before = false;
>    static constexpr const float_round_style round_style = round_toward_zero;
>};
>
>template <>
>class __libcpp_numeric_limits<bool, true>
>{
>protected:
>    typedef bool type;
>
>    static constexpr const bool is_specialized = true;
>
>    static constexpr const bool is_signed = false;
>    static constexpr const int digits = 1;
>    static constexpr const int digits10 = 0;
>    static constexpr const int max_digits10 = 0;
>    static constexpr const type __min = false;
>    static constexpr const type __max = true;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return __min;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return __max;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return min();}
>
>    static constexpr const bool is_integer = true;
>    static constexpr const bool is_exact = true;
>    static constexpr const int radix = 2;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return type(0);}
>
>    static constexpr const int min_exponent = 0;
>    static constexpr const int min_exponent10 = 0;
>    static constexpr const int max_exponent = 0;
>    static constexpr const int max_exponent10 = 0;
>
>    static constexpr const bool has_infinity = false;
>    static constexpr const bool has_quiet_NaN = false;
>    static constexpr const bool has_signaling_NaN = false;
>    static constexpr const float_denorm_style has_denorm = denorm_absent;
>    static constexpr const bool has_denorm_loss = false;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return type(0);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return type(0);}
>
>    static constexpr const bool is_iec559 = false;
>    static constexpr const bool is_bounded = true;
>    static constexpr const bool is_modulo = false;
>
>    static constexpr const bool traps = false;
>    static constexpr const bool tinyness_before = false;
>    static constexpr const float_round_style round_style = round_toward_zero;
>};
>
>template <>
>class __libcpp_numeric_limits<float, true>
>{
>protected:
>    typedef float type;
>
>    static constexpr const bool is_specialized = true;
>
>    static constexpr const bool is_signed = true;
>    static constexpr const int digits = 24;
>    static constexpr const int digits10 = 6;
>    static constexpr const int max_digits10 = 2+(digits * 30103)/100000;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return 1.1754943508222875e-38F;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return 3.4028234663852886e+38F;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return -max();}
>
>    static constexpr const bool is_integer = false;
>    static constexpr const bool is_exact = false;
>    static constexpr const int radix = 2;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return 1.1920928955078125e-7F;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return 0.5F;}
>
>    static constexpr const int min_exponent = (-125);
>    static constexpr const int min_exponent10 = (-37);
>    static constexpr const int max_exponent = 128;
>    static constexpr const int max_exponent10 = 38;
>
>    static constexpr const bool has_infinity = true;
>    static constexpr const bool has_quiet_NaN = true;
>    static constexpr const bool has_signaling_NaN = true;
>    static constexpr const float_denorm_style has_denorm = denorm_present;
>    static constexpr const bool has_denorm_loss = false;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return __builtin_huge_valf();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return __builtin_nanf("");}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return __builtin_nansf("");}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return 1.4012984643248171e-45F;}
>
>    static constexpr const bool is_iec559 = true;
>    static constexpr const bool is_bounded = true;
>    static constexpr const bool is_modulo = false;
>
>    static constexpr const bool traps = false;
>    static constexpr const bool tinyness_before = false;
>    static constexpr const float_round_style round_style = round_to_nearest;
>};
>
>template <>
>class __libcpp_numeric_limits<double, true>
>{
>protected:
>    typedef double type;
>
>    static constexpr const bool is_specialized = true;
>
>    static constexpr const bool is_signed = true;
>    static constexpr const int digits = 53;
>    static constexpr const int digits10 = 15;
>    static constexpr const int max_digits10 = 2+(digits * 30103)/100000;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return double(2.2250738585072014e-308L);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return double(1.7976931348623157e+308L);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return -max();}
>
>    static constexpr const bool is_integer = false;
>    static constexpr const bool is_exact = false;
>    static constexpr const int radix = 2;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return double(2.2204460492503131e-16L);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return 0.5;}
>
>    static constexpr const int min_exponent = (-1021);
>    static constexpr const int min_exponent10 = (-307);
>    static constexpr const int max_exponent = 1024;
>    static constexpr const int max_exponent10 = 308;
>
>    static constexpr const bool has_infinity = true;
>    static constexpr const bool has_quiet_NaN = true;
>    static constexpr const bool has_signaling_NaN = true;
>    static constexpr const float_denorm_style has_denorm = denorm_present;
>    static constexpr const bool has_denorm_loss = false;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return __builtin_huge_val();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return __builtin_nan("");}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return __builtin_nans("");}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return double(4.9406564584124654e-324L);}
>
>    static constexpr const bool is_iec559 = true;
>    static constexpr const bool is_bounded = true;
>    static constexpr const bool is_modulo = false;
>
>    static constexpr const bool traps = false;
>    static constexpr const bool tinyness_before = false;
>    static constexpr const float_round_style round_style = round_to_nearest;
>};
>
>template <>
>class __libcpp_numeric_limits<long double, true>
>{
>protected:
>    typedef long double type;
>
>    static constexpr const bool is_specialized = true;
>
>    static constexpr const bool is_signed = true;
>    static constexpr const int digits = 53;
>    static constexpr const int digits10 = 15;
>    static constexpr const int max_digits10 = 2+(digits * 30103)/100000;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return 2.2250738585072014e-308L;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return 1.7976931348623157e+308L;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return -max();}
>
>    static constexpr const bool is_integer = false;
>    static constexpr const bool is_exact = false;
>    static constexpr const int radix = 2;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return 2.2204460492503131e-16L;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return 0.5;}
>
>    static constexpr const int min_exponent = (-1021);
>    static constexpr const int min_exponent10 = (-307);
>    static constexpr const int max_exponent = 1024;
>    static constexpr const int max_exponent10 = 308;
>
>    static constexpr const bool has_infinity = true;
>    static constexpr const bool has_quiet_NaN = true;
>    static constexpr const bool has_signaling_NaN = true;
>    static constexpr const float_denorm_style has_denorm = denorm_present;
>    static constexpr const bool has_denorm_loss = false;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return __builtin_huge_vall();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return __builtin_nanl("");}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return __builtin_nansl("");}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return 4.9406564584124654e-324L;}
>
>
>
>
>    static constexpr const bool is_iec559 = true;
>
>    static constexpr const bool is_bounded = true;
>    static constexpr const bool is_modulo = false;
>
>    static constexpr const bool traps = false;
>    static constexpr const bool tinyness_before = false;
>    static constexpr const float_round_style round_style = round_to_nearest;
>};
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) numeric_limits
>    : private __libcpp_numeric_limits<typename remove_cv<_Tp>::type>
>{
>    typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base;
>    typedef typename __base::type type;
>public:
>    static constexpr const bool is_specialized = __base::is_specialized;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return __base::min();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return __base::max();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return __base::lowest();}
>
>    static constexpr const int digits = __base::digits;
>    static constexpr const int digits10 = __base::digits10;
>    static constexpr const int max_digits10 = __base::max_digits10;
>    static constexpr const bool is_signed = __base::is_signed;
>    static constexpr const bool is_integer = __base::is_integer;
>    static constexpr const bool is_exact = __base::is_exact;
>    static constexpr const int radix = __base::radix;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return __base::epsilon();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return __base::round_error();}
>
>    static constexpr const int min_exponent = __base::min_exponent;
>    static constexpr const int min_exponent10 = __base::min_exponent10;
>    static constexpr const int max_exponent = __base::max_exponent;
>    static constexpr const int max_exponent10 = __base::max_exponent10;
>
>    static constexpr const bool has_infinity = __base::has_infinity;
>    static constexpr const bool has_quiet_NaN = __base::has_quiet_NaN;
>    static constexpr const bool has_signaling_NaN = __base::has_signaling_NaN;
>    static constexpr const float_denorm_style has_denorm = __base::has_denorm;
>    static constexpr const bool has_denorm_loss = __base::has_denorm_loss;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return __base::infinity();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return __base::quiet_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return __base::signaling_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return __base::denorm_min();}
>
>    static constexpr const bool is_iec559 = __base::is_iec559;
>    static constexpr const bool is_bounded = __base::is_bounded;
>    static constexpr const bool is_modulo = __base::is_modulo;
>
>    static constexpr const bool traps = __base::traps;
>    static constexpr const bool tinyness_before = __base::tinyness_before;
>    static constexpr const float_round_style round_style = __base::round_style;
>};
>
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::is_specialized;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::digits;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::digits10;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::max_digits10;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::is_signed;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::is_integer;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::is_exact;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::radix;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::min_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::min_exponent10;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::max_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<_Tp>::max_exponent10;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::has_infinity;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::has_quiet_NaN;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::has_signaling_NaN;
>template <class _Tp>
>    constexpr const float_denorm_style numeric_limits<_Tp>::has_denorm;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::has_denorm_loss;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::is_iec559;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::is_bounded;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::is_modulo;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::traps;
>template <class _Tp>
>    constexpr const bool numeric_limits<_Tp>::tinyness_before;
>template <class _Tp>
>    constexpr const float_round_style numeric_limits<_Tp>::round_style;
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) numeric_limits<const _Tp>
>    : private numeric_limits<_Tp>
>{
>    typedef numeric_limits<_Tp> __base;
>    typedef _Tp type;
>public:
>    static constexpr const bool is_specialized = __base::is_specialized;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return __base::min();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return __base::max();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return __base::lowest();}
>
>    static constexpr const int digits = __base::digits;
>    static constexpr const int digits10 = __base::digits10;
>    static constexpr const int max_digits10 = __base::max_digits10;
>    static constexpr const bool is_signed = __base::is_signed;
>    static constexpr const bool is_integer = __base::is_integer;
>    static constexpr const bool is_exact = __base::is_exact;
>    static constexpr const int radix = __base::radix;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return __base::epsilon();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return __base::round_error();}
>
>    static constexpr const int min_exponent = __base::min_exponent;
>    static constexpr const int min_exponent10 = __base::min_exponent10;
>    static constexpr const int max_exponent = __base::max_exponent;
>    static constexpr const int max_exponent10 = __base::max_exponent10;
>
>    static constexpr const bool has_infinity = __base::has_infinity;
>    static constexpr const bool has_quiet_NaN = __base::has_quiet_NaN;
>    static constexpr const bool has_signaling_NaN = __base::has_signaling_NaN;
>    static constexpr const float_denorm_style has_denorm = __base::has_denorm;
>    static constexpr const bool has_denorm_loss = __base::has_denorm_loss;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return __base::infinity();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return __base::quiet_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return __base::signaling_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return __base::denorm_min();}
>
>    static constexpr const bool is_iec559 = __base::is_iec559;
>    static constexpr const bool is_bounded = __base::is_bounded;
>    static constexpr const bool is_modulo = __base::is_modulo;
>
>    static constexpr const bool traps = __base::traps;
>    static constexpr const bool tinyness_before = __base::tinyness_before;
>    static constexpr const float_round_style round_style = __base::round_style;
>};
>
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::is_specialized;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::digits;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::digits10;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::max_digits10;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::is_signed;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::is_integer;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::is_exact;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::radix;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::min_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::min_exponent10;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::max_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<const _Tp>::max_exponent10;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::has_infinity;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::has_quiet_NaN;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::has_signaling_NaN;
>template <class _Tp>
>    constexpr const float_denorm_style numeric_limits<const _Tp>::has_denorm;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::has_denorm_loss;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::is_iec559;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::is_bounded;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::is_modulo;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::traps;
>template <class _Tp>
>    constexpr const bool numeric_limits<const _Tp>::tinyness_before;
>template <class _Tp>
>    constexpr const float_round_style numeric_limits<const _Tp>::round_style;
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) numeric_limits<volatile _Tp>
>    : private numeric_limits<_Tp>
>{
>    typedef numeric_limits<_Tp> __base;
>    typedef _Tp type;
>public:
>    static constexpr const bool is_specialized = __base::is_specialized;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return __base::min();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return __base::max();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return __base::lowest();}
>
>    static constexpr const int digits = __base::digits;
>    static constexpr const int digits10 = __base::digits10;
>    static constexpr const int max_digits10 = __base::max_digits10;
>    static constexpr const bool is_signed = __base::is_signed;
>    static constexpr const bool is_integer = __base::is_integer;
>    static constexpr const bool is_exact = __base::is_exact;
>    static constexpr const int radix = __base::radix;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return __base::epsilon();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return __base::round_error();}
>
>    static constexpr const int min_exponent = __base::min_exponent;
>    static constexpr const int min_exponent10 = __base::min_exponent10;
>    static constexpr const int max_exponent = __base::max_exponent;
>    static constexpr const int max_exponent10 = __base::max_exponent10;
>
>    static constexpr const bool has_infinity = __base::has_infinity;
>    static constexpr const bool has_quiet_NaN = __base::has_quiet_NaN;
>    static constexpr const bool has_signaling_NaN = __base::has_signaling_NaN;
>    static constexpr const float_denorm_style has_denorm = __base::has_denorm;
>    static constexpr const bool has_denorm_loss = __base::has_denorm_loss;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return __base::infinity();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return __base::quiet_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return __base::signaling_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return __base::denorm_min();}
>
>    static constexpr const bool is_iec559 = __base::is_iec559;
>    static constexpr const bool is_bounded = __base::is_bounded;
>    static constexpr const bool is_modulo = __base::is_modulo;
>
>    static constexpr const bool traps = __base::traps;
>    static constexpr const bool tinyness_before = __base::tinyness_before;
>    static constexpr const float_round_style round_style = __base::round_style;
>};
>
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::is_specialized;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::digits;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::digits10;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::max_digits10;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::is_signed;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::is_integer;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::is_exact;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::radix;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::min_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::min_exponent10;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::max_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<volatile _Tp>::max_exponent10;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::has_infinity;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::has_quiet_NaN;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::has_signaling_NaN;
>template <class _Tp>
>    constexpr const float_denorm_style numeric_limits<volatile _Tp>::has_denorm;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::has_denorm_loss;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::is_iec559;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::is_bounded;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::is_modulo;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::traps;
>template <class _Tp>
>    constexpr const bool numeric_limits<volatile _Tp>::tinyness_before;
>template <class _Tp>
>    constexpr const float_round_style numeric_limits<volatile _Tp>::round_style;
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) numeric_limits<const volatile _Tp>
>    : private numeric_limits<_Tp>
>{
>    typedef numeric_limits<_Tp> __base;
>    typedef _Tp type;
>public:
>    static constexpr const bool is_specialized = __base::is_specialized;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type min() throw() {return __base::min();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type max() throw() {return __base::max();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type lowest() throw() {return __base::lowest();}
>
>    static constexpr const int digits = __base::digits;
>    static constexpr const int digits10 = __base::digits10;
>    static constexpr const int max_digits10 = __base::max_digits10;
>    static constexpr const bool is_signed = __base::is_signed;
>    static constexpr const bool is_integer = __base::is_integer;
>    static constexpr const bool is_exact = __base::is_exact;
>    static constexpr const int radix = __base::radix;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type epsilon() throw() {return __base::epsilon();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type round_error() throw() {return __base::round_error();}
>
>    static constexpr const int min_exponent = __base::min_exponent;
>    static constexpr const int min_exponent10 = __base::min_exponent10;
>    static constexpr const int max_exponent = __base::max_exponent;
>    static constexpr const int max_exponent10 = __base::max_exponent10;
>
>    static constexpr const bool has_infinity = __base::has_infinity;
>    static constexpr const bool has_quiet_NaN = __base::has_quiet_NaN;
>    static constexpr const bool has_signaling_NaN = __base::has_signaling_NaN;
>    static constexpr const float_denorm_style has_denorm = __base::has_denorm;
>    static constexpr const bool has_denorm_loss = __base::has_denorm_loss;
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type infinity() throw() {return __base::infinity();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type quiet_NaN() throw() {return __base::quiet_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type signaling_NaN() throw() {return __base::signaling_NaN();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) static constexpr type denorm_min() throw() {return __base::denorm_min();}
>
>    static constexpr const bool is_iec559 = __base::is_iec559;
>    static constexpr const bool is_bounded = __base::is_bounded;
>    static constexpr const bool is_modulo = __base::is_modulo;
>
>    static constexpr const bool traps = __base::traps;
>    static constexpr const bool tinyness_before = __base::tinyness_before;
>    static constexpr const float_round_style round_style = __base::round_style;
>};
>
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::is_specialized;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::digits;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::digits10;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::max_digits10;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::is_signed;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::is_integer;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::is_exact;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::radix;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::min_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::min_exponent10;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::max_exponent;
>template <class _Tp>
>    constexpr const int numeric_limits<const volatile _Tp>::max_exponent10;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::has_infinity;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::has_quiet_NaN;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::has_signaling_NaN;
>template <class _Tp>
>    constexpr const float_denorm_style numeric_limits<const volatile _Tp>::has_denorm;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::has_denorm_loss;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::is_iec559;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::is_bounded;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::is_modulo;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::traps;
>template <class _Tp>
>    constexpr const bool numeric_limits<const volatile _Tp>::tinyness_before;
>template <class _Tp>
>    constexpr const float_round_style numeric_limits<const volatile _Tp>::round_style;
>
>} }
>       
>
>
>namespace std { namespace __1 {
>
>template <class _Arg, class _Result>
>struct __attribute__ ((__visibility__("default"))) unary_function
>{
>    typedef _Arg argument_type;
>    typedef _Result result_type;
>};
>
>template <class _Arg1, class _Arg2, class _Result>
>struct __attribute__ ((__visibility__("default"))) binary_function
>{
>    typedef _Arg1 first_argument_type;
>    typedef _Arg2 second_argument_type;
>    typedef _Result result_type;
>};
>
>template <class _Tp> struct __attribute__ ((__visibility__("default"))) hash;
>
>template <class _Tp>
>struct __has_result_type
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::result_type* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>
>
>
>template <class _Tp>
>
>struct __attribute__ ((__visibility__("default"))) less : binary_function<_Tp, _Tp, bool>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _Tp& __x, const _Tp& __y) const
>        {return __x < __y;}
>};
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp*
>addressof(_Tp& __x) throw()
>{
>    return (_Tp*)&reinterpret_cast<const volatile char&>(__x);
>}
>template <class _Tp>
>struct __derives_from_unary_function
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    static __two __test(...);
>    template <class _Ap, class _Rp>
>        static unary_function<_Ap, _Rp>
>        __test(const volatile unary_function<_Ap, _Rp>*);
>public:
>    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
>    typedef decltype(__test((_Tp*)0)) type;
>};
>
>template <class _Tp>
>struct __derives_from_binary_function
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    static __two __test(...);
>    template <class _A1, class _A2, class _Rp>
>        static binary_function<_A1, _A2, _Rp>
>        __test(const volatile binary_function<_A1, _A2, _Rp>*);
>public:
>    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
>    typedef decltype(__test((_Tp*)0)) type;
>};
>
>template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
>struct __maybe_derive_from_unary_function
>    : public __derives_from_unary_function<_Tp>::type
>{
>};
>
>template <class _Tp>
>struct __maybe_derive_from_unary_function<_Tp, false>
>{
>};
>
>template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
>struct __maybe_derive_from_binary_function
>    : public __derives_from_binary_function<_Tp>::type
>{
>};
>
>template <class _Tp>
>struct __maybe_derive_from_binary_function<_Tp, false>
>{
>};
>
>template <class _Tp, bool = __has_result_type<_Tp>::value>
>struct __weak_result_type_imp
>    : public __maybe_derive_from_unary_function<_Tp>,
>      public __maybe_derive_from_binary_function<_Tp>
>{
>    typedef typename _Tp::result_type result_type;
>};
>
>template <class _Tp>
>struct __weak_result_type_imp<_Tp, false>
>    : public __maybe_derive_from_unary_function<_Tp>,
>      public __maybe_derive_from_binary_function<_Tp>
>{
>};
>
>template <class _Tp>
>struct __weak_result_type
>    : public __weak_result_type_imp<_Tp>
>{
>};
>
>
>
>template <class _Rp>
>struct __weak_result_type<_Rp ()>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp>
>struct __weak_result_type<_Rp (&)()>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp>
>struct __weak_result_type<_Rp (*)()>
>{
>    typedef _Rp result_type;
>};
>
>
>
>template <class _Rp, class _A1>
>struct __weak_result_type<_Rp (_A1)>
>    : public unary_function<_A1, _Rp>
>{
>};
>
>template <class _Rp, class _A1>
>struct __weak_result_type<_Rp (&)(_A1)>
>    : public unary_function<_A1, _Rp>
>{
>};
>
>template <class _Rp, class _A1>
>struct __weak_result_type<_Rp (*)(_A1)>
>    : public unary_function<_A1, _Rp>
>{
>};
>
>template <class _Rp, class _Cp>
>struct __weak_result_type<_Rp (_Cp::*)()>
>    : public unary_function<_Cp*, _Rp>
>{
>};
>
>template <class _Rp, class _Cp>
>struct __weak_result_type<_Rp (_Cp::*)() const>
>    : public unary_function<const _Cp*, _Rp>
>{
>};
>
>template <class _Rp, class _Cp>
>struct __weak_result_type<_Rp (_Cp::*)() volatile>
>    : public unary_function<volatile _Cp*, _Rp>
>{
>};
>
>template <class _Rp, class _Cp>
>struct __weak_result_type<_Rp (_Cp::*)() const volatile>
>    : public unary_function<const volatile _Cp*, _Rp>
>{
>};
>
>
>
>template <class _Rp, class _A1, class _A2>
>struct __weak_result_type<_Rp (_A1, _A2)>
>    : public binary_function<_A1, _A2, _Rp>
>{
>};
>
>template <class _Rp, class _A1, class _A2>
>struct __weak_result_type<_Rp (*)(_A1, _A2)>
>    : public binary_function<_A1, _A2, _Rp>
>{
>};
>
>template <class _Rp, class _A1, class _A2>
>struct __weak_result_type<_Rp (&)(_A1, _A2)>
>    : public binary_function<_A1, _A2, _Rp>
>{
>};
>
>template <class _Rp, class _Cp, class _A1>
>struct __weak_result_type<_Rp (_Cp::*)(_A1)>
>    : public binary_function<_Cp*, _A1, _Rp>
>{
>};
>
>template <class _Rp, class _Cp, class _A1>
>struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
>    : public binary_function<const _Cp*, _A1, _Rp>
>{
>};
>
>template <class _Rp, class _Cp, class _A1>
>struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
>    : public binary_function<volatile _Cp*, _A1, _Rp>
>{
>};
>
>template <class _Rp, class _Cp, class _A1>
>struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
>    : public binary_function<const volatile _Cp*, _A1, _Rp>
>{
>};
>
>
>
>template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
>struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
>struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
>struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
>struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
>struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
>struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
>{
>    typedef _Rp result_type;
>};
>
>template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
>struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
>{
>    typedef _Rp result_type;
>};
>
>
>
>
>
>template <class _Fp, class _A0, class ..._Args,
>            class>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
>    -> decltype((std::__1::forward<_A0>(__a0).*__f)(std::__1::forward<_Args>(__args)...))
>{
>    return (std::__1::forward<_A0>(__a0).*__f)(std::__1::forward<_Args>(__args)...);
>}
>
>template <class _Fp, class _A0, class ..._Args,
>            class>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
>    -> decltype(((*std::__1::forward<_A0>(__a0)).*__f)(std::__1::forward<_Args>(__args)...))
>{
>    return ((*std::__1::forward<_A0>(__a0)).*__f)(std::__1::forward<_Args>(__args)...);
>}
>
>
>
>template <class _Fp, class _A0,
>            class>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0)
>    -> decltype(std::__1::forward<_A0>(__a0).*__f)
>{
>    return std::__1::forward<_A0>(__a0).*__f;
>}
>
>template <class _Fp, class _A0,
>            class>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _A0&& __a0)
>    -> decltype((*std::__1::forward<_A0>(__a0)).*__f)
>{
>    return (*std::__1::forward<_A0>(__a0)).*__f;
>}
>
>
>
>template <class _Fp, class ..._Args>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>auto
>__invoke(_Fp&& __f, _Args&& ...__args)
>    -> decltype(std::__1::forward<_Fp>(__f)(std::__1::forward<_Args>(__args)...))
>{
>    return std::__1::forward<_Fp>(__f)(std::__1::forward<_Args>(__args)...);
>}
>
>template <class _Tp, class ..._Args>
>struct __invoke_return
>{
>    typedef decltype(__invoke(std::__1::declval<_Tp>(), std::__1::declval<_Args>()...)) type;
>};
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) reference_wrapper
>    : public __weak_result_type<_Tp>
>{
>public:
>
>    typedef _Tp type;
>private:
>    type* __f_;
>
>public:
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reference_wrapper(type& __f) throw()
>        : __f_(std::__1::addressof(__f)) {}
>
>    private: reference_wrapper(type&&); public:
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) operator type& () const throw() {return *__f_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) type& get() const throw() {return *__f_;}
>
>
>    template <class... _ArgTypes>
>       __attribute__ ((__visibility__("hidden"), __always_inline__))
>       typename __invoke_of<type&, _ArgTypes...>::type
>          operator() (_ArgTypes&&... __args) const
>          {
>              return __invoke(get(), std::__1::forward<_ArgTypes>(__args)...);
>          }
>};
>
>template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
>template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
>template <class _Tp> struct __is_reference_wrapper
>    : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {};
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>reference_wrapper<_Tp>
>ref(_Tp& __t) throw()
>{
>    return reference_wrapper<_Tp>(__t);
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>reference_wrapper<_Tp>
>ref(reference_wrapper<_Tp> __t) throw()
>{
>    return ref(__t.get());
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>reference_wrapper<const _Tp>
>cref(const _Tp& __t) throw()
>{
>    return reference_wrapper<const _Tp>(__t);
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>reference_wrapper<const _Tp>
>cref(reference_wrapper<_Tp> __t) throw()
>{
>    return cref(__t.get());
>}
>
>
>
>
>template <class _Tp> void ref(const _Tp&&) = delete;
>template <class _Tp> void cref(const _Tp&&) = delete;
>struct __attribute__ ((__visibility__("default"))) allocator_arg_t { };
>
>
>
>
>constexpr allocator_arg_t allocator_arg = allocator_arg_t();
>
>
>
>
>template <class _Tp>
>struct __has_allocator_type
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::allocator_type* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
>struct __uses_allocator
>    : public integral_constant<bool,
>        is_convertible<_Alloc, typename _Tp::allocator_type>::value>
>{
>};
>
>template <class _Tp, class _Alloc>
>struct __uses_allocator<_Tp, _Alloc, false>
>    : public false_type
>{
>};
>
>template <class _Tp, class _Alloc>
>struct __attribute__ ((__visibility__("default"))) uses_allocator
>    : public __uses_allocator<_Tp, _Alloc>
>{
>};
>
>
>
>
>
>template <class _Tp, class _Alloc, class ..._Args>
>struct __uses_alloc_ctor_imp
>{
>    static const bool __ua = uses_allocator<_Tp, _Alloc>::value;
>    static const bool __ic =
>        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
>    static const int value = __ua ? 2 - __ic : 0;
>};
>
>template <class _Tp, class _Alloc, class ..._Args>
>struct __uses_alloc_ctor
>    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
>    {};
>
>template <class _Tp, class _Allocator, class... _Args>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
>{
>    new (__storage) _Tp (std::__1::forward<_Args>(__args)...);
>}
>
>template <class _Tp, class _Allocator, class... _Args>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
>{
>    new (__storage) _Tp (allocator_arg, __a, std::__1::forward<_Args>(__args)...);
>}
>
>template <class _Tp, class _Allocator, class... _Args>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
>{
>    new (__storage) _Tp (std::__1::forward<_Args>(__args)..., __a);
>}
>
>template <class _Tp, class _Allocator, class... _Args>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args)
>{
>    __user_alloc_construct_impl(
>             __uses_alloc_ctor<_Tp, _Allocator>(),
>             __storage, __a, std::__1::forward<_Args>(__args)...
>        );
>}
>
>
>} }
>
>
>extern "C" {
>
>
>typedef __builtin_va_list __gnuc_va_list;
>typedef __gnuc_va_list va_list;
>
>
>
>
>
>typedef off_t fpos_t;
>struct __sbuf {
> unsigned char *_base;
> int _size;
>};
>typedef struct __sFILE {
> unsigned char *_p;
> int _r;
> int _w;
> short _flags;
> short _file;
> struct __sbuf _bf;
> int _lbfsize;
>
>
> void *_cookie;
> int (*_close)(void *);
> int (*_read)(void *, char *, int);
> fpos_t (*_seek)(void *, fpos_t, int);
> int (*_write)(void *, const char *, int);
>
>
> struct __sbuf _ext;
>
> unsigned char *_up;
> int _ur;
>
>
> unsigned char _ubuf[3];
> unsigned char _nbuf[1];
>
>
> struct __sbuf _lb;
>
>
> int _blksize;
> fpos_t _offset;
>} FILE;
>
>extern "C" {
>extern FILE __sF[];
>}
>extern "C" {
>void clearerr(FILE *);
>int fclose(FILE *);
>int feof(FILE *);
>int ferror(FILE *);
>int fflush(FILE *);
>int fgetc(FILE *);
>int fgetpos(FILE *, fpos_t *);
>char *fgets(char *, int, FILE *);
>FILE *fopen(const char *, const char *);
>int fprintf(FILE *, const char *, ...);
>int fputc(int, FILE *);
>int fputs(const char *, FILE *);
>size_t fread(void *, size_t, size_t, FILE *);
>FILE *freopen(const char *, const char *, FILE *);
>int fscanf(FILE *, const char *, ...);
>int fseek(FILE *, long, int);
>int fseeko(FILE *, off_t, int);
>int fsetpos(FILE *, const fpos_t *);
>long ftell(FILE *);
>off_t ftello(FILE *);
>size_t fwrite(const void *, size_t, size_t, FILE *);
>int getc(FILE *);
>int getchar(void);
>char *gets(char *);
>
>
>
>extern int sys_nerr;
>extern char *sys_errlist[];
>
>void perror(const char *);
>int printf(const char *, ...);
>int putc(int, FILE *);
>int putchar(int);
>int puts(const char *);
>int remove(const char *);
>int rename(const char *, const char *);
>void rewind(FILE *);
>int scanf(const char *, ...);
>void setbuf(FILE *, char *);
>int setvbuf(FILE *, char *, int, size_t);
>int sprintf(char *, const char *, ...);
>int sscanf(const char *, const char *, ...);
>FILE *tmpfile(void);
>char *tmpnam(char *);
>int ungetc(int, FILE *);
>int vfprintf(FILE *, const char *, __gnuc_va_list);
>int vprintf(const char *, __gnuc_va_list);
>int vsprintf(char *, const char *, __gnuc_va_list);
>
>
>int snprintf(char *, size_t, const char *, ...)
>  __attribute__((__format__ (printf, 3, 4)))
>  __attribute__((__nonnull__ (3)));
>int vfscanf(FILE *, const char *, __gnuc_va_list)
>  __attribute__((__format__ (scanf, 2, 0)))
>  __attribute__((__nonnull__ (2)));
>int vscanf(const char *, __gnuc_va_list)
>  __attribute__((__format__ (scanf, 1, 0)))
>  __attribute__((__nonnull__ (1)));
>int vsnprintf(char *, size_t, const char *, __gnuc_va_list)
>  __attribute__((__format__ (printf, 3, 0)))
>  __attribute__((__nonnull__ (3)));
>int vsscanf(const char *, const char *, __gnuc_va_list)
>  __attribute__((__format__ (scanf, 2, 0)))
>  __attribute__((__nonnull__ (2)));
>
>
>}
>extern "C" {
>
>
>
>
>FILE *fdopen(int, const char *);
>int fileno(FILE *);
>
>
>int pclose(FILE *);
>FILE *popen(const char *, const char *);
>
>
>
>void flockfile(FILE *);
>int ftrylockfile(FILE *);
>void funlockfile(FILE *);
>
>
>
>
>
>int getc_unlocked(FILE *);
>int getchar_unlocked(void);
>int putc_unlocked(int, FILE *);
>int putchar_unlocked(int);
>
>
>
>char *tempnam(const char *, const char *);
>
>}
>
>
>
>
>
>
>
>extern "C" {
>int asprintf(char **, const char *, ...)
>  __attribute__((__format__ (printf, 2, 3)))
>  __attribute__((__nonnull__ (2)));
>char *fgetln(FILE *, size_t *);
>int fpurge(FILE *);
>int getw(FILE *);
>int putw(int, FILE *);
>void setbuffer(FILE *, char *, int);
>int setlinebuf(FILE *);
>int vasprintf(char **, const char *, __gnuc_va_list)
>  __attribute__((__format__ (printf, 2, 0)))
>  __attribute__((__nonnull__ (2)));
>}
>
>
>
>
>extern "C" {
>FILE *funopen(const void *,
>  int (*)(void *, char *, int),
>  int (*)(void *, const char *, int),
>  fpos_t (*)(void *, fpos_t, int),
>  int (*)(void *));
>}
>
>
>
>
>
>
>
>extern "C" {
>int __srget(FILE *);
>int __swbuf(int, FILE *);
>}
>
>
>
>
>
>
>
>static inline int __sputc(int _c, FILE *_p) {
> if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
>  return (*_p->_p++ = _c);
> else
>  return (__swbuf(_c, _p));
>}
>int fdprintf(int, const char*, ...);
>int vfdprintf(int, const char*, __gnuc_va_list);
>extern "C" {
>
>
>typedef int wint_t;
>typedef int wctrans_t;
>typedef int wctype_t;
>
>
>
>int iswalnum(wint_t);
>int iswalpha(wint_t);
>int iswblank(wint_t);
>int iswcntrl(wint_t);
>int iswdigit(wint_t);
>int iswgraph(wint_t);
>int iswlower(wint_t);
>int iswprint(wint_t);
>int iswpunct(wint_t);
>int iswspace(wint_t);
>int iswupper(wint_t);
>int iswxdigit(wint_t);
>int iswctype(wint_t, wctype_t);
>wint_t towctrans(wint_t, wctrans_t);
>wint_t towlower(wint_t);
>wint_t towupper(wint_t);
>wctrans_t wctrans(const char *);
>wctype_t wctype(const char *);
>
>int iswalnum_l(wint_t, locale_t);
>int iswalpha_l(wint_t, locale_t);
>int iswblank_l(wint_t, locale_t);
>int iswcntrl_l(wint_t, locale_t);
>int iswdigit_l(wint_t, locale_t);
>int iswgraph_l(wint_t, locale_t);
>int iswlower_l(wint_t, locale_t);
>int iswprint_l(wint_t, locale_t);
>int iswpunct_l(wint_t, locale_t);
>int iswspace_l(wint_t, locale_t);
>int iswupper_l(wint_t, locale_t);
>int iswxdigit_l(wint_t, locale_t);
>int iswctype_l(wint_t, wctype_t, locale_t);
>
>wint_t towlower_l(wint_t, locale_t);
>wint_t towupper_l(wint_t, locale_t);
>wint_t towctrans_l(wint_t, wctrans_t, locale_t);
>wctrans_t wctrans_l(const char *, locale_t);
>wctype_t wctype_l(const char *, locale_t);
>
>
>}
>
>
>
>typedef struct
>{
>  unsigned __opaque1, __opaque2;
>} mbstate_t;
>
>wchar_t *wcscpy (wchar_t *__restrict__, const wchar_t *__restrict__);
>wchar_t *wcsncpy (wchar_t *__restrict__, const wchar_t *__restrict__, size_t);
>
>wchar_t *wcscat (wchar_t *__restrict__, const wchar_t *__restrict__);
>wchar_t *wcsncat (wchar_t *__restrict__, const wchar_t *__restrict__, size_t);
>
>int wcscmp (const wchar_t *, const wchar_t *);
>int wcsncmp (const wchar_t *, const wchar_t *, size_t);
>
>int wcscoll(const wchar_t *, const wchar_t *);
>size_t wcsxfrm (wchar_t *__restrict__, const wchar_t *__restrict__, size_t n);
>
>wchar_t *wcschr (const wchar_t *, wchar_t);
>wchar_t *wcsrchr (const wchar_t *, wchar_t);
>
>size_t wcscspn (const wchar_t *, const wchar_t *);
>size_t wcsspn (const wchar_t *, const wchar_t *);
>wchar_t *wcspbrk (const wchar_t *, const wchar_t *);
>
>wchar_t *wcstok (wchar_t *__restrict__, const wchar_t *__restrict__, wchar_t **__restrict__);
>
>size_t wcslen (const wchar_t *);
>
>wchar_t *wcsstr (const wchar_t *__restrict__, const wchar_t *__restrict__);
>wchar_t *wcswcs (const wchar_t *, const wchar_t *);
>
>wchar_t *wmemchr (const wchar_t *, wchar_t, size_t);
>int wmemcmp (const wchar_t *, const wchar_t *, size_t);
>wchar_t *wmemcpy (wchar_t *__restrict__, const wchar_t *__restrict__, size_t);
>wchar_t *wmemmove (wchar_t *, const wchar_t *, size_t);
>wchar_t *wmemset (wchar_t *, wchar_t, size_t);
>
>wint_t btowc (int);
>int wctob (wint_t);
>
>int mbsinit (const mbstate_t *);
>size_t mbrtowc (wchar_t *__restrict__, const char *__restrict__, size_t, mbstate_t *__restrict__);
>size_t wcrtomb (char *__restrict__, wchar_t, mbstate_t *__restrict__);
>
>size_t mbrlen (const char *__restrict__, size_t, mbstate_t *__restrict__);
>
>size_t mbsrtowcs (wchar_t *__restrict__, const char **__restrict__, size_t, mbstate_t *__restrict__);
>size_t wcsrtombs (char *__restrict__, const wchar_t **__restrict__, size_t, mbstate_t *__restrict__);
>
>float wcstof (const wchar_t *__restrict__, wchar_t **__restrict__);
>double wcstod (const wchar_t *__restrict__, wchar_t **__restrict__);
>long double wcstold (const wchar_t *__restrict__, wchar_t **__restrict__);
>
>long wcstol (const wchar_t *__restrict__, wchar_t **__restrict__, int);
>unsigned long wcstoul (const wchar_t *__restrict__, wchar_t **__restrict__, int);
>
>long long wcstoll (const wchar_t *__restrict__, wchar_t **__restrict__, int);
>unsigned long long wcstoull (const wchar_t *__restrict__, wchar_t **__restrict__, int);
>intmax_t wcstoimax (const wchar_t * nptr, wchar_t** endptr , int base);
>uintmax_t wcstoumax (const wchar_t * nptr, wchar_t** endptr , int base);
>
>
>int fwide (FILE *, int);
>
>
>int wprintf (const wchar_t *__restrict__, ...);
>int fwprintf (FILE *__restrict__, const wchar_t *__restrict__, ...);
>int swprintf (wchar_t *__restrict__, size_t, const wchar_t *__restrict__, ...);
>
>int vwprintf (const wchar_t *__restrict__, va_list);
>int vfwprintf (FILE *__restrict__, const wchar_t *__restrict__, va_list);
>int vswprintf (wchar_t *__restrict__, size_t, const wchar_t *__restrict__, va_list);
>
>int wscanf (const wchar_t *__restrict__, ...);
>int fwscanf (FILE *__restrict__, const wchar_t *__restrict__, ...);
>int swscanf (const wchar_t *__restrict__, const wchar_t *__restrict__, ...);
>
>int vwscanf (const wchar_t *__restrict__, va_list);
>int vfwscanf (FILE *__restrict__, const wchar_t *__restrict__, va_list);
>int vswscanf (const wchar_t *__restrict__, const wchar_t *__restrict__, va_list);
>
>wint_t fgetwc (FILE *);
>wint_t getwc (FILE *);
>wint_t getwchar (void);
>
>wint_t fputwc (wchar_t, FILE *);
>wint_t putwc (wchar_t, FILE *);
>wint_t putwchar (wchar_t);
>
>wchar_t *fgetws (wchar_t *__restrict__, int, FILE *__restrict__);
>int fputws (const wchar_t *__restrict__, FILE *__restrict__);
>
>wint_t ungetwc (wint_t, FILE *);
>
>struct tm;
>size_t wcsftime (wchar_t *__restrict__, size_t, const wchar_t *__restrict__, const struct tm *__restrict__);
>
>FILE *open_wmemstream(wchar_t **, size_t *);
>size_t mbsnrtowcs(wchar_t *__restrict__, const char **__restrict__, size_t, size_t, mbstate_t *__restrict__);
>size_t wcsnrtombs(char *__restrict__, const wchar_t **__restrict__, size_t, size_t, mbstate_t *__restrict__);
>wchar_t *wcsdup(const wchar_t *);
>size_t wcsnlen (const wchar_t *, size_t);
>wchar_t *wcpcpy (wchar_t *__restrict__, const wchar_t *__restrict__);
>wchar_t *wcpncpy (wchar_t *__restrict__, const wchar_t *__restrict__, size_t);
>int wcscasecmp(const wchar_t *, const wchar_t *);
>int wcscasecmp_l(const wchar_t *, const wchar_t *, locale_t);
>int wcsncasecmp(const wchar_t *, const wchar_t *, size_t);
>int wcsncasecmp_l(const wchar_t *, const wchar_t *, size_t, locale_t);
>int wcscoll_l(const wchar_t *, const wchar_t *, locale_t);
>size_t wcsxfrm_l(wchar_t *__restrict__, const wchar_t *__restrict__, size_t n, locale_t);
>
>int wcwidth (wchar_t);
>int wcswidth (const wchar_t *, size_t);
>int iswalnum(wint_t);
>int iswalpha(wint_t);
>int iswblank(wint_t);
>int iswcntrl(wint_t);
>int iswdigit(wint_t);
>int iswgraph(wint_t);
>int iswlower(wint_t);
>int iswprint(wint_t);
>int iswpunct(wint_t);
>int iswspace(wint_t);
>int iswupper(wint_t);
>int iswxdigit(wint_t);
>int iswctype(wint_t, wctype_t);
>wint_t towlower(wint_t);
>wint_t towupper(wint_t);
>wctype_t wctype(const char *);
>
>
>}
>
>
>       
>
>
>namespace std { namespace __1 {
>
>class __attribute__ ((__visibility__("default"))) ios_base;
>
>template<class _CharT> struct __attribute__ ((__visibility__("default"))) char_traits;
>template<class _Tp> class __attribute__ ((__visibility__("default"))) allocator;
>
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_ios;
>
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_streambuf;
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_istream;
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_ostream;
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_iostream;
>
>template <class _CharT, class _Traits = char_traits<_CharT>,
>          class _Allocator = allocator<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_stringbuf;
>template <class _CharT, class _Traits = char_traits<_CharT>,
>          class _Allocator = allocator<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_istringstream;
>template <class _CharT, class _Traits = char_traits<_CharT>,
>          class _Allocator = allocator<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_ostringstream;
>template <class _CharT, class _Traits = char_traits<_CharT>,
>          class _Allocator = allocator<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_stringstream;
>
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_filebuf;
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_ifstream;
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_ofstream;
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_fstream;
>
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) istreambuf_iterator;
>template <class _CharT, class _Traits = char_traits<_CharT> >
>    class __attribute__ ((__visibility__("default"))) ostreambuf_iterator;
>
>typedef basic_ios<char> ios;
>typedef basic_ios<wchar_t> wios;
>
>typedef basic_streambuf<char> streambuf;
>typedef basic_istream<char> istream;
>typedef basic_ostream<char> ostream;
>typedef basic_iostream<char> iostream;
>
>typedef basic_stringbuf<char> stringbuf;
>typedef basic_istringstream<char> istringstream;
>typedef basic_ostringstream<char> ostringstream;
>typedef basic_stringstream<char> stringstream;
>
>typedef basic_filebuf<char> filebuf;
>typedef basic_ifstream<char> ifstream;
>typedef basic_ofstream<char> ofstream;
>typedef basic_fstream<char> fstream;
>
>typedef basic_streambuf<wchar_t> wstreambuf;
>typedef basic_istream<wchar_t> wistream;
>typedef basic_ostream<wchar_t> wostream;
>typedef basic_iostream<wchar_t> wiostream;
>
>typedef basic_stringbuf<wchar_t> wstringbuf;
>typedef basic_istringstream<wchar_t> wistringstream;
>typedef basic_ostringstream<wchar_t> wostringstream;
>typedef basic_stringstream<wchar_t> wstringstream;
>
>typedef basic_filebuf<wchar_t> wfilebuf;
>typedef basic_ifstream<wchar_t> wifstream;
>typedef basic_ofstream<wchar_t> wofstream;
>typedef basic_fstream<wchar_t> wfstream;
>
>template <class _State> class __attribute__ ((__visibility__("default"))) fpos;
>typedef fpos<mbstate_t> streampos;
>typedef fpos<mbstate_t> wstreampos;
>
>typedef fpos<mbstate_t> u16streampos;
>typedef fpos<mbstate_t> u32streampos;
>
>
>typedef long long streamoff;
>
>template <class _CharT,
>          class _Traits = char_traits<_CharT>,
>          class _Allocator = allocator<_CharT> >
>    class __attribute__ ((__visibility__("default"))) basic_string;
>typedef basic_string<char, char_traits<char>, allocator<char> > string;
>typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
>
>} }
>       
>
>
>namespace std
>{
>
>
>
>template<class _Ep>
>class __attribute__ ((__visibility__("default"))) initializer_list
>{
>    const _Ep* __begin_;
>    size_t __size_;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>   
>    initializer_list(const _Ep* __b, size_t __s) throw()
>        : __begin_(__b),
>          __size_(__s)
>        {}
>public:
>    typedef _Ep value_type;
>    typedef const _Ep& reference;
>    typedef const _Ep& const_reference;
>    typedef size_t size_type;
>
>    typedef const _Ep* iterator;
>    typedef const _Ep* const_iterator;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>   
>    initializer_list() throw() : __begin_(nullptr), __size_(0) {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>   
>    size_t size() const throw() {return __size_;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>   
>    const _Ep* begin() const throw() {return __begin_;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>   
>    const _Ep* end() const throw() {return __begin_ + __size_;}
>};
>
>template<class _Ep>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>
>const _Ep*
>begin(initializer_list<_Ep> __il) throw()
>{
>    return __il.begin();
>}
>
>template<class _Ep>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>
>const _Ep*
>end(initializer_list<_Ep> __il) throw()
>{
>    return __il.end();
>}
>
>
>
>}
>       
>
>
>namespace std { namespace __1 {
>
>struct __attribute__ ((__visibility__("default"))) input_iterator_tag {};
>struct __attribute__ ((__visibility__("default"))) output_iterator_tag {};
>struct __attribute__ ((__visibility__("default"))) forward_iterator_tag : public input_iterator_tag {};
>struct __attribute__ ((__visibility__("default"))) bidirectional_iterator_tag : public forward_iterator_tag {};
>struct __attribute__ ((__visibility__("default"))) random_access_iterator_tag : public bidirectional_iterator_tag {};
>
>template <class _Tp>
>struct __has_iterator_category
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::iterator_category* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Iter, bool> struct __iterator_traits_impl {};
>
>template <class _Iter>
>struct __iterator_traits_impl<_Iter, true>
>{
>    typedef typename _Iter::difference_type difference_type;
>    typedef typename _Iter::value_type value_type;
>    typedef typename _Iter::pointer pointer;
>    typedef typename _Iter::reference reference;
>    typedef typename _Iter::iterator_category iterator_category;
>};
>
>template <class _Iter, bool> struct __iterator_traits {};
>
>template <class _Iter>
>struct __iterator_traits<_Iter, true>
>    : __iterator_traits_impl
>      <
>        _Iter,
>        is_convertible<typename _Iter::iterator_category, input_iterator_tag>::value ||
>        is_convertible<typename _Iter::iterator_category, output_iterator_tag>::value
>      >
>{};
>
>
>
>
>
>
>template <class _Iter>
>struct __attribute__ ((__visibility__("default"))) iterator_traits
>    : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {};
>
>template<class _Tp>
>struct __attribute__ ((__visibility__("default"))) iterator_traits<_Tp*>
>{
>    typedef ptrdiff_t difference_type;
>    typedef typename remove_const<_Tp>::type value_type;
>    typedef _Tp* pointer;
>    typedef _Tp& reference;
>    typedef random_access_iterator_tag iterator_category;
>};
>
>template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value>
>struct __has_iterator_category_convertible_to
>    : public integral_constant<bool, is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up>::value>
>{};
>
>template <class _Tp, class _Up>
>struct __has_iterator_category_convertible_to<_Tp, _Up, false> : public false_type {};
>
>template <class _Tp>
>struct __is_input_iterator : public __has_iterator_category_convertible_to<_Tp, input_iterator_tag> {};
>
>template <class _Tp>
>struct __is_forward_iterator : public __has_iterator_category_convertible_to<_Tp, forward_iterator_tag> {};
>
>template <class _Tp>
>struct __is_bidirectional_iterator : public __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag> {};
>
>template <class _Tp>
>struct __is_random_access_iterator : public __has_iterator_category_convertible_to<_Tp, random_access_iterator_tag> {};
>
>template<class _Category, class _Tp, class _Distance = ptrdiff_t,
>         class _Pointer = _Tp*, class _Reference = _Tp&>
>struct __attribute__ ((__visibility__("default"))) iterator
>{
>    typedef _Tp value_type;
>    typedef _Distance difference_type;
>    typedef _Pointer pointer;
>    typedef _Reference reference;
>    typedef _Category iterator_category;
>};
>
>template <class _InputIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void __advance(_InputIter& __i,
>             typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag)
>{
>    for (; __n > 0; --__n)
>        ++__i;
>}
>
>template <class _BiDirIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void __advance(_BiDirIter& __i,
>             typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag)
>{
>    if (__n >= 0)
>        for (; __n > 0; --__n)
>            ++__i;
>    else
>        for (; __n < 0; ++__n)
>            --__i;
>}
>
>template <class _RandIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void __advance(_RandIter& __i,
>             typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag)
>{
>   __i += __n;
>}
>
>template <class _InputIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void advance(_InputIter& __i,
>             typename iterator_traits<_InputIter>::difference_type __n)
>{
>    __advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
>}
>
>template <class _InputIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename iterator_traits<_InputIter>::difference_type
>__distance(_InputIter __first, _InputIter __last, input_iterator_tag)
>{
>    typename iterator_traits<_InputIter>::difference_type __r(0);
>    for (; __first != __last; ++__first)
>        ++__r;
>    return __r;
>}
>
>template <class _RandIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename iterator_traits<_RandIter>::difference_type
>__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
>{
>    return __last - __first;
>}
>
>template <class _InputIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename iterator_traits<_InputIter>::difference_type
>distance(_InputIter __first, _InputIter __last)
>{
>    return __distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
>}
>
>template <class _ForwardIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIter
>next(_ForwardIter __x,
>     typename iterator_traits<_ForwardIter>::difference_type __n = 1,
>     typename enable_if<__is_forward_iterator<_ForwardIter>::value>::type* = 0)
>{
>    std::__1::advance(__x, __n);
>    return __x;
>}
>
>template <class _BidiretionalIter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_BidiretionalIter
>prev(_BidiretionalIter __x,
>     typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
>     typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
>{
>    std::__1::advance(__x, -__n);
>    return __x;
>}
>
>template <class _Iter>
>class __attribute__ ((__visibility__("default"))) reverse_iterator
>    : public iterator<typename iterator_traits<_Iter>::iterator_category,
>                      typename iterator_traits<_Iter>::value_type,
>                      typename iterator_traits<_Iter>::difference_type,
>                      typename iterator_traits<_Iter>::pointer,
>                      typename iterator_traits<_Iter>::reference>
>{
>private:
>    mutable _Iter __t;
>protected:
>    _Iter current;
>public:
>    typedef _Iter iterator_type;
>    typedef typename iterator_traits<_Iter>::difference_type difference_type;
>    typedef typename iterator_traits<_Iter>::reference reference;
>    typedef typename iterator_traits<_Iter>::pointer pointer;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator() : current() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
>    template <class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator(const reverse_iterator<_Up>& __u)
>        : __t(__u.base()), current(__u.base()) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Iter base() const {return current;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reference operator*() const {_Iter __tmp = current; return *--__tmp;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer operator->() const {return std::__1::addressof(operator*());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator& operator++() {--current; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator operator++(int)
>        {reverse_iterator __tmp(*this); --current; return __tmp;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator& operator--() {++current; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator operator--(int)
>        {reverse_iterator __tmp(*this); ++current; return __tmp;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator operator+ (difference_type __n) const
>        {return reverse_iterator(current - __n);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator& operator+=(difference_type __n)
>        {current -= __n; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator operator- (difference_type __n) const
>        {return reverse_iterator(current + __n);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reverse_iterator& operator-=(difference_type __n)
>        {current += __n; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reference operator[](difference_type __n) const
>        {return current[-__n-1];}
>};
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
>{
>    return __x.base() == __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
>{
>    return __x.base() > __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
>{
>    return __x.base() != __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
>{
>    return __x.base() < __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
>{
>    return __x.base() <= __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
>{
>    return __x.base() >= __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename reverse_iterator<_Iter1>::difference_type
>operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
>{
>    return __y.base() - __x.base();
>}
>
>template <class _Iter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>reverse_iterator<_Iter>
>operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
>{
>    return reverse_iterator<_Iter>(__x.base() - __n);
>}
>template <class _Container>
>class __attribute__ ((__visibility__("default"))) back_insert_iterator
>    : public iterator<output_iterator_tag,
>                      void,
>                      void,
>                      void,
>                      back_insert_iterator<_Container>&>
>{
>protected:
>    _Container* container;
>public:
>    typedef _Container container_type;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit back_insert_iterator(_Container& __x) : container(std::__1::addressof(__x)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) back_insert_iterator& operator=(const typename _Container::value_type& __value_)
>        {container->push_back(__value_); return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) back_insert_iterator& operator=(typename _Container::value_type&& __value_)
>        {container->push_back(std::__1::move(__value_)); return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) back_insert_iterator& operator*() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) back_insert_iterator& operator++() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) back_insert_iterator operator++(int) {return *this;}
>};
>
>template <class _Container>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>back_insert_iterator<_Container>
>back_inserter(_Container& __x)
>{
>    return back_insert_iterator<_Container>(__x);
>}
>
>template <class _Container>
>class __attribute__ ((__visibility__("default"))) front_insert_iterator
>    : public iterator<output_iterator_tag,
>                      void,
>                      void,
>                      void,
>                      front_insert_iterator<_Container>&>
>{
>protected:
>    _Container* container;
>public:
>    typedef _Container container_type;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit front_insert_iterator(_Container& __x) : container(std::__1::addressof(__x)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) front_insert_iterator& operator=(const typename _Container::value_type& __value_)
>        {container->push_front(__value_); return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) front_insert_iterator& operator=(typename _Container::value_type&& __value_)
>        {container->push_front(std::__1::move(__value_)); return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) front_insert_iterator& operator*() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) front_insert_iterator& operator++() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) front_insert_iterator operator++(int) {return *this;}
>};
>
>template <class _Container>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>front_insert_iterator<_Container>
>front_inserter(_Container& __x)
>{
>    return front_insert_iterator<_Container>(__x);
>}
>
>template <class _Container>
>class __attribute__ ((__visibility__("default"))) insert_iterator
>    : public iterator<output_iterator_tag,
>                      void,
>                      void,
>                      void,
>                      insert_iterator<_Container>&>
>{
>protected:
>    _Container* container;
>    typename _Container::iterator iter;
>public:
>    typedef _Container container_type;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) insert_iterator(_Container& __x, typename _Container::iterator __i)
>        : container(std::__1::addressof(__x)), iter(__i) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) insert_iterator& operator=(const typename _Container::value_type& __value_)
>        {iter = container->insert(iter, __value_); ++iter; return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) insert_iterator& operator=(typename _Container::value_type&& __value_)
>        {iter = container->insert(iter, std::__1::move(__value_)); ++iter; return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) insert_iterator& operator*() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) insert_iterator& operator++() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) insert_iterator& operator++(int) {return *this;}
>};
>
>template <class _Container>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>insert_iterator<_Container>
>inserter(_Container& __x, typename _Container::iterator __i)
>{
>    return insert_iterator<_Container>(__x, __i);
>}
>
>template <class _Tp, class _CharT = char,
>          class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
>class __attribute__ ((__visibility__("default"))) istream_iterator
>    : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
>{
>public:
>    typedef _CharT char_type;
>    typedef _Traits traits_type;
>    typedef basic_istream<_CharT,_Traits> istream_type;
>private:
>    istream_type* __in_stream_;
>    _Tp __value_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istream_iterator() : __in_stream_(0) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istream_iterator(istream_type& __s) : __in_stream_(&__s)
>        {
>            if (!(*__in_stream_ >> __value_))
>                __in_stream_ = 0;
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) const _Tp& operator*() const {return __value_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) const _Tp* operator->() const {return &(operator*());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istream_iterator& operator++()
>        {
>            if (!(*__in_stream_ >> __value_))
>                __in_stream_ = 0;
>            return *this;
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istream_iterator operator++(int)
>        {istream_iterator __t(*this); ++(*this); return __t;}
>
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator==(const istream_iterator& __x, const istream_iterator& __y)
>        {return __x.__in_stream_ == __y.__in_stream_;}
>
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator!=(const istream_iterator& __x, const istream_iterator& __y)
>        {return !(__x == __y);}
>};
>
>template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
>class __attribute__ ((__visibility__("default"))) ostream_iterator
>    : public iterator<output_iterator_tag, void, void, void, void>
>{
>public:
>    typedef _CharT char_type;
>    typedef _Traits traits_type;
>    typedef basic_ostream<_CharT,_Traits> ostream_type;
>private:
>    ostream_type* __out_stream_;
>    const char_type* __delim_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostream_iterator(ostream_type& __s)
>        : __out_stream_(&__s), __delim_(0) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostream_iterator(ostream_type& __s, const _CharT* __delimiter)
>        : __out_stream_(&__s), __delim_(__delimiter) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostream_iterator& operator=(const _Tp& __value_)
>        {
>            *__out_stream_ << __value_;
>            if (__delim_)
>                *__out_stream_ << __delim_;
>            return *this;
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostream_iterator& operator*() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostream_iterator& operator++() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostream_iterator& operator++(int) {return *this;}
>};
>
>template<class _CharT, class _Traits>
>class __attribute__ ((__visibility__("default"))) istreambuf_iterator
>    : public iterator<input_iterator_tag, _CharT,
>                      typename _Traits::off_type, _CharT*,
>                      _CharT>
>{
>public:
>    typedef _CharT char_type;
>    typedef _Traits traits_type;
>    typedef typename _Traits::int_type int_type;
>    typedef basic_streambuf<_CharT,_Traits> streambuf_type;
>    typedef basic_istream<_CharT,_Traits> istream_type;
>private:
>    mutable streambuf_type* __sbuf_;
>
>    class __proxy
>    {
>        char_type __keep_;
>        streambuf_type* __sbuf_;
>        __attribute__ ((__visibility__("hidden"), __always_inline__)) __proxy(char_type __c, streambuf_type* __s)
>            : __keep_(__c), __sbuf_(__s) {}
>        friend class istreambuf_iterator;
>    public:
>        __attribute__ ((__visibility__("hidden"), __always_inline__)) char_type operator*() const {return __keep_;}
>    };
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool __test_for_eof() const
>    {
>        if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
>            __sbuf_ = 0;
>        return __sbuf_ == 0;
>    }
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr istreambuf_iterator() throw() : __sbuf_(0) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istreambuf_iterator(istream_type& __s) throw()
>        : __sbuf_(__s.rdbuf()) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istreambuf_iterator(streambuf_type* __s) throw()
>        : __sbuf_(__s) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istreambuf_iterator(const __proxy& __p) throw()
>        : __sbuf_(__p.__sbuf_) {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) char_type operator*() const
>        {return static_cast<char_type>(__sbuf_->sgetc());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) char_type* operator->() const {return nullptr;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) istreambuf_iterator& operator++()
>        {
>            __sbuf_->sbumpc();
>            return *this;
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __proxy operator++(int)
>        {
>            return __proxy(__sbuf_->sbumpc(), __sbuf_);
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) bool equal(const istreambuf_iterator& __b) const
>        {return __test_for_eof() == __b.__test_for_eof();}
>};
>
>template <class _CharT, class _Traits>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
>                const istreambuf_iterator<_CharT,_Traits>& __b)
>                {return __a.equal(__b);}
>
>template <class _CharT, class _Traits>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
>                const istreambuf_iterator<_CharT,_Traits>& __b)
>                {return !__a.equal(__b);}
>
>template <class _CharT, class _Traits>
>class __attribute__ ((__visibility__("default"))) ostreambuf_iterator
>    : public iterator<output_iterator_tag, void, void, void, void>
>{
>public:
>    typedef _CharT char_type;
>    typedef _Traits traits_type;
>    typedef basic_streambuf<_CharT,_Traits> streambuf_type;
>    typedef basic_ostream<_CharT,_Traits> ostream_type;
>private:
>    streambuf_type* __sbuf_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostreambuf_iterator(ostream_type& __s) throw()
>        : __sbuf_(__s.rdbuf()) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostreambuf_iterator(streambuf_type* __s) throw()
>        : __sbuf_(__s) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostreambuf_iterator& operator=(_CharT __c)
>        {
>            if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
>                __sbuf_ = 0;
>            return *this;
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostreambuf_iterator& operator*() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostreambuf_iterator& operator++() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ostreambuf_iterator& operator++(int) {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) bool failed() const throw() {return __sbuf_ == 0;}
>
>
>
>
>
>    template <class _Ch, class _Tr>
>    friend
>    __attribute__ ((__visibility__("hidden")))
>    ostreambuf_iterator<_Ch, _Tr>
>    __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
>                     const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
>                     ios_base& __iob, _Ch __fl);
>
>};
>
>template <class _Iter>
>class __attribute__ ((__visibility__("default"))) move_iterator
>{
>private:
>    _Iter __i;
>public:
>    typedef _Iter iterator_type;
>    typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
>    typedef typename iterator_traits<iterator_type>::value_type value_type;
>    typedef typename iterator_traits<iterator_type>::difference_type difference_type;
>    typedef typename iterator_traits<iterator_type>::pointer pointer;
>
>    typedef value_type&& reference;
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator() : __i() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit move_iterator(_Iter __x) : __i(__x) {}
>    template <class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator(const move_iterator<_Up>& __u)
>        : __i(__u.base()) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Iter base() const {return __i;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reference operator*() const {
>      return static_cast<reference>(*__i);
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer operator->() const {
>      typename iterator_traits<iterator_type>::reference __ref = *__i;
>      return &__ref;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator& operator++() {++__i; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator operator++(int)
>        {move_iterator __tmp(*this); ++__i; return __tmp;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator& operator--() {--__i; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator operator--(int)
>        {move_iterator __tmp(*this); --__i; return __tmp;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator operator+ (difference_type __n) const
>        {return move_iterator(__i + __n);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator& operator+=(difference_type __n)
>        {__i += __n; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator operator- (difference_type __n) const
>        {return move_iterator(__i - __n);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) move_iterator& operator-=(difference_type __n)
>        {__i -= __n; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reference operator[](difference_type __n) const
>    {
>      return static_cast<reference>(__i[__n]);
>    }
>};
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
>{
>    return __x.base() == __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
>{
>    return __x.base() < __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
>{
>    return __x.base() != __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
>{
>    return __x.base() > __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
>{
>    return __x.base() >= __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
>{
>    return __x.base() <= __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename move_iterator<_Iter1>::difference_type
>operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
>{
>    return __x.base() - __y.base();
>}
>
>template <class _Iter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>move_iterator<_Iter>
>operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
>{
>    return move_iterator<_Iter>(__x.base() + __n);
>}
>
>template <class _Iter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>move_iterator<_Iter>
>make_move_iterator(_Iter __i)
>{
>    return move_iterator<_Iter>(__i);
>}
>
>
>
>template <class _Iter> class __wrap_iter;
>
>template <class _Iter1, class _Iter2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>template <class _Iter1, class _Iter2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>template <class _Iter1, class _Iter2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>template <class _Iter1, class _Iter2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>template <class _Iter1, class _Iter2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>template <class _Iter1, class _Iter2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>template <class _Iter1, class _Iter2>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>typename __wrap_iter<_Iter1>::difference_type
>operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>template <class _Iter>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>__wrap_iter<_Iter>
>operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) throw();
>
>template <class _Ip, class _Op> _Op __attribute__ ((__visibility__("hidden"), __always_inline__)) copy(_Ip, _Ip, _Op);
>template <class _B1, class _B2> _B2 __attribute__ ((__visibility__("hidden"), __always_inline__)) copy_backward(_B1, _B1, _B2);
>template <class _Ip, class _Op> _Op __attribute__ ((__visibility__("hidden"), __always_inline__)) move(_Ip, _Ip, _Op);
>template <class _B1, class _B2> _B2 __attribute__ ((__visibility__("hidden"), __always_inline__)) move_backward(_B1, _B1, _B2);
>
>template <class _Tp>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_trivially_copy_assignable<_Tp>::value,
>    _Tp*
>>::type
>__unwrap_iter(__wrap_iter<_Tp*>);
>
>template <class _Iter>
>class __wrap_iter
>{
>public:
>    typedef _Iter iterator_type;
>    typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
>    typedef typename iterator_traits<iterator_type>::value_type value_type;
>    typedef typename iterator_traits<iterator_type>::difference_type difference_type;
>    typedef typename iterator_traits<iterator_type>::pointer pointer;
>    typedef typename iterator_traits<iterator_type>::reference reference;
>private:
>    iterator_type __i;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter() throw()
>
>
>
>    {
>
>
>
>    }
>    template <class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter(const __wrap_iter<_Up>& __u,
>        typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0) throw()
>        : __i(__u.base())
>    {
>
>
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reference operator*() const throw()
>    {
>
>
>
>
>        return *__i;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer operator->() const throw()
>    {
>
>
>
>
>        return (pointer)&reinterpret_cast<const volatile char&>(*__i);
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter& operator++() throw()
>    {
>
>
>
>
>        ++__i;
>        return *this;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter operator++(int) throw()
>        {__wrap_iter __tmp(*this); ++(*this); return __tmp;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter& operator--() throw()
>    {
>
>
>
>
>        --__i;
>        return *this;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter operator--(int) throw()
>        {__wrap_iter __tmp(*this); --(*this); return __tmp;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter operator+ (difference_type __n) const throw()
>        {__wrap_iter __w(*this); __w += __n; return __w;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter& operator+=(difference_type __n) throw()
>    {
>
>
>
>
>        __i += __n;
>        return *this;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter operator- (difference_type __n) const throw()
>        {return *this + (-__n);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter& operator-=(difference_type __n) throw()
>        {*this += -__n; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) reference operator[](difference_type __n) const throw()
>    {
>
>
>
>
>        return __i[__n];
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) iterator_type base() const throw() {return __i;}
>
>private:
>
>
>
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __wrap_iter(iterator_type __x) throw() : __i(__x) {}
>
>
>    template <class _Up> friend class __wrap_iter;
>    template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
>    template <class _Tp, class _Alloc> friend class vector;
>
>    template <class _Iter1, class _Iter2>
>    friend
>    bool
>    operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>    template <class _Iter1, class _Iter2>
>    friend
>    bool
>    operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>    template <class _Iter1, class _Iter2>
>    friend
>    bool
>    operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>    template <class _Iter1, class _Iter2>
>    friend
>    bool
>    operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>    template <class _Iter1, class _Iter2>
>    friend
>    bool
>    operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>    template <class _Iter1, class _Iter2>
>    friend
>    bool
>    operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>    template <class _Iter1, class _Iter2>
>    friend
>    typename __wrap_iter<_Iter1>::difference_type
>    operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) throw();
>
>    template <class _Iter1>
>    friend
>    __wrap_iter<_Iter1>
>    operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) throw();
>
>    template <class _Ip, class _Op> friend _Op copy(_Ip, _Ip, _Op);
>    template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
>    template <class _Ip, class _Op> friend _Op move(_Ip, _Ip, _Op);
>    template <class _B1, class _B2> friend _B2 move_backward(_B1, _B1, _B2);
>
>    template <class _Tp>
>    friend
>    typename enable_if
>    <
>        is_trivially_copy_assignable<_Tp>::value,
>        _Tp*
>    >::type
>    __unwrap_iter(__wrap_iter<_Tp*>);
>};
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) throw()
>{
>    return __x.base() == __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) throw()
>{
>
>
>
>
>    return __x.base() < __y.base();
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) throw()
>{
>    return !(__x == __y);
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) throw()
>{
>    return __y < __x;
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) throw()
>{
>    return !(__x < __y);
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) throw()
>{
>    return !(__y < __x);
>}
>
>template <class _Iter1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) throw()
>{
>    return !(__x == __y);
>}
>
>template <class _Iter1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) throw()
>{
>    return __y < __x;
>}
>
>template <class _Iter1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) throw()
>{
>    return !(__x < __y);
>}
>
>template <class _Iter1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) throw()
>{
>    return !(__y < __x);
>}
>
>template <class _Iter1, class _Iter2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename __wrap_iter<_Iter1>::difference_type
>operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) throw()
>{
>
>
>
>
>    return __x.base() - __y.base();
>}
>
>template <class _Iter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>__wrap_iter<_Iter>
>operator+(typename __wrap_iter<_Iter>::difference_type __n,
>          __wrap_iter<_Iter> __x) throw()
>{
>    __x += __n;
>    return __x;
>}
>
>template <class _Tp, size_t _Np>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp*
>begin(_Tp (&__array)[_Np])
>{
>    return __array;
>}
>
>template <class _Tp, size_t _Np>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp*
>end(_Tp (&__array)[_Np])
>{
>    return __array + _Np;
>}
>template <class _Cp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename _Cp::iterator
>begin(_Cp& __c)
>{
>    return __c.begin();
>}
>
>template <class _Cp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename _Cp::const_iterator
>begin(const _Cp& __c)
>{
>    return __c.begin();
>}
>
>template <class _Cp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename _Cp::iterator
>end(_Cp& __c)
>{
>    return __c.end();
>}
>
>template <class _Cp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename _Cp::const_iterator
>end(const _Cp& __c)
>{
>    return __c.end();
>}
>
>
>
>} }
>
>
>       
>
>
>namespace std { namespace __1 {
>
>
>
>
>
>template <class ..._Tp>
>class __attribute__ ((__visibility__("default"))) tuple_size<tuple<_Tp...> >
>    : public integral_constant<size_t, sizeof...(_Tp)>
>{
>};
>
>
>
>template <size_t _Ip, class ..._Tp>
>class __attribute__ ((__visibility__("default"))) tuple_element<_Ip, tuple<_Tp...> >
>{
>public:
>    typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
>};
>template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value
>
>
>
>         >
>class __tuple_leaf;
>
>template <size_t _Ip, class _Hp, bool _Ep>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
>   
>{
>    swap(__x.get(), __y.get());
>}
>
>template <size_t _Ip, class _Hp, bool>
>class __tuple_leaf
>{
>    _Hp value;
>
>    __tuple_leaf& operator=(const __tuple_leaf&);
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr __tuple_leaf()
>             : value()
>       {static_assert(!is_reference<_Hp>::value,
>              "Attempted to default construct a reference element in a tuple");}
>
>    template <class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
>            : value()
>        {static_assert(!is_reference<_Hp>::value,
>              "Attempted to default construct a reference element in a tuple");}
>
>    template <class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
>            : value(allocator_arg_t(), __a)
>        {static_assert(!is_reference<_Hp>::value,
>              "Attempted to default construct a reference element in a tuple");}
>
>    template <class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
>            : value(__a)
>        {static_assert(!is_reference<_Hp>::value,
>              "Attempted to default construct a reference element in a tuple");}
>
>    template <class _Tp,
>              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(_Tp&& __t)
>            : value(std::__1::forward<_Tp>(__t))
>        {static_assert(!is_reference<_Hp>::value ||
>                       (is_lvalue_reference<_Hp>::value &&
>                        (is_lvalue_reference<_Tp>::value ||
>                         is_same<typename remove_reference<_Tp>::type,
>                                 reference_wrapper<
>                                    typename remove_reference<_Hp>::type
>                                 >
>                                >::value)) ||
>                        (is_rvalue_reference<_Hp>::value &&
>                         !is_lvalue_reference<_Tp>::value),
>       "Attempted to construct a reference element in a tuple with an rvalue");}
>
>    template <class _Tp, class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
>            : value(std::__1::forward<_Tp>(__t))
>        {static_assert(!is_lvalue_reference<_Hp>::value ||
>                       (is_lvalue_reference<_Hp>::value &&
>                        (is_lvalue_reference<_Tp>::value ||
>                         is_same<typename remove_reference<_Tp>::type,
>                                 reference_wrapper<
>                                    typename remove_reference<_Hp>::type
>                                 >
>                                >::value)),
>       "Attempted to construct a reference element in a tuple with an rvalue");}
>
>    template <class _Tp, class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
>            : value(allocator_arg_t(), __a, std::__1::forward<_Tp>(__t))
>        {static_assert(!is_lvalue_reference<_Hp>::value ||
>                       (is_lvalue_reference<_Hp>::value &&
>                        (is_lvalue_reference<_Tp>::value ||
>                         is_same<typename remove_reference<_Tp>::type,
>                                 reference_wrapper<
>                                    typename remove_reference<_Hp>::type
>                                 >
>                                >::value)),
>       "Attempted to construct a reference element in a tuple with an rvalue");}
>
>    template <class _Tp, class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
>            : value(std::__1::forward<_Tp>(__t), __a)
>        {static_assert(!is_lvalue_reference<_Hp>::value ||
>                       (is_lvalue_reference<_Hp>::value &&
>                        (is_lvalue_reference<_Tp>::value ||
>                         is_same<typename remove_reference<_Tp>::type,
>                                 reference_wrapper<
>                                    typename remove_reference<_Hp>::type
>                                 >
>                                >::value)),
>       "Attempted to construct a reference element in a tuple with an rvalue");}
>
>    __tuple_leaf(const __tuple_leaf& __t) = default;
>    __tuple_leaf(__tuple_leaf&& __t) = default;
>
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf&
>        operator=(_Tp&& __t)
>        {
>            value = std::__1::forward<_Tp>(__t);
>            return *this;
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    int swap(__tuple_leaf& __t)
>    {
>        std::__1::swap(*this, __t);
>        return 0;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Hp& get() throw() {return value;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) const _Hp& get() const throw() {return value;}
>};
>
>template <size_t _Ip, class _Hp>
>class __tuple_leaf<_Ip, _Hp, true>
>    : private _Hp
>{
>
>    __tuple_leaf& operator=(const __tuple_leaf&);
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr __tuple_leaf()
>             {}
>
>    template <class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
>
>    template <class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
>            : _Hp(allocator_arg_t(), __a) {}
>
>    template <class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
>            : _Hp(__a) {}
>
>    template <class _Tp,
>              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(_Tp&& __t)
>            : _Hp(std::__1::forward<_Tp>(__t)) {}
>
>    template <class _Tp, class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
>            : _Hp(std::__1::forward<_Tp>(__t)) {}
>
>    template <class _Tp, class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
>            : _Hp(allocator_arg_t(), __a, std::__1::forward<_Tp>(__t)) {}
>
>    template <class _Tp, class _Alloc>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
>            : _Hp(std::__1::forward<_Tp>(__t), __a) {}
>
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_leaf&
>        operator=(_Tp&& __t)
>        {
>            _Hp::operator=(std::__1::forward<_Tp>(__t));
>            return *this;
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    int
>    swap(__tuple_leaf& __t)
>    {
>        std::__1::swap(*this, __t);
>        return 0;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Hp& get() throw() {return static_cast<_Hp&>(*this);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) const _Hp& get() const throw() {return static_cast<const _Hp&>(*this);}
>};
>
>template <class ..._Tp>
>__attribute__ ((__visibility__("hidden"), __always_inline__))
>void __swallow(_Tp&&...) throw() {}
>
>template <bool ...> struct __all;
>
>template <>
>struct __all<>
>{
>    static const bool value = true;
>};
>
>template <bool _B0, bool ... _Bp>
>struct __all<_B0, _Bp...>
>{
>    static const bool value = _B0 && __all<_Bp...>::value;
>};
>
>
>
>template<class _Indx, class ..._Tp> struct __tuple_impl;
>
>template<size_t ..._Indx, class ..._Tp>
>struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
>    : public __tuple_leaf<_Indx, _Tp>...
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    constexpr __tuple_impl()
>        {}
>
>    template <size_t ..._Uf, class ..._Tf,
>              size_t ..._Ul, class ..._Tl, class ..._Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit
>        __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
>                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
>                     _Up&&... __u)
>                    
>                                                                                                 :
>            __tuple_leaf<_Uf, _Tf>(std::__1::forward<_Up>(__u))...,
>            __tuple_leaf<_Ul, _Tl>()...
>            {}
>
>    template <class _Alloc, size_t ..._Uf, class ..._Tf,
>              size_t ..._Ul, class ..._Tl, class ..._Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit
>        __tuple_impl(allocator_arg_t, const _Alloc& __a,
>                     __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
>                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
>                     _Up&&... __u) :
>            __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
>            std::__1::forward<_Up>(__u))...,
>            __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
>            {}
>
>    template <class _Tuple,
>              class = typename enable_if
>                      <
>                         __tuple_constructible<_Tuple, tuple<_Tp...> >::value
>                      >::type
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_impl(_Tuple&& __t)
>
>            : __tuple_leaf<_Indx, _Tp>(std::__1::forward<typename tuple_element<_Indx,
>                                       typename __make_tuple_types<_Tuple>::type>::type>(std::__1::get<_Indx>(__t)))...
>            {}
>
>    template <class _Alloc, class _Tuple,
>              class = typename enable_if
>                      <
>                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
>                      >::type
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
>            : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
>                                       typename __make_tuple_types<_Tuple>::type>::type>(), __a,
>                                       std::__1::forward<typename tuple_element<_Indx,
>                                       typename __make_tuple_types<_Tuple>::type>::type>(std::__1::get<_Indx>(__t)))...
>            {}
>
>    template <class _Tuple>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        typename enable_if
>        <
>            __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
>            __tuple_impl&
>        >::type
>        operator=(_Tuple&& __t)
>
>        {
>            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(std::__1::forward<typename tuple_element<_Indx,
>                                       typename __make_tuple_types<_Tuple>::type>::type>(std::__1::get<_Indx>(__t)))...);
>            return *this;
>        }
>
>    __tuple_impl(const __tuple_impl&) = default;
>    __tuple_impl(__tuple_impl&&) = default;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __tuple_impl&
>    operator=(const __tuple_impl& __t)
>    {
>        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
>        return *this;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __tuple_impl&
>    operator=(__tuple_impl&& __t)
>    {
>        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(std::__1::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
>        return *this;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void swap(__tuple_impl& __t)
>       
>    {
>        __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
>    }
>};
>
>template <class ..._Tp>
>class __attribute__ ((__visibility__("default"))) tuple
>{
>    typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base;
>
>    base base_;
>
>    template <size_t _Jp, class ..._Up> friend
>        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) throw();
>    template <size_t _Jp, class ..._Up> friend
>        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) throw();
>    template <size_t _Jp, class ..._Up> friend
>        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) throw();
>public:
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    constexpr tuple()
>        {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit tuple(const _Tp& ... __t)
>        : base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
>                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
>                typename __make_tuple_indices<0>::type(),
>                typename __make_tuple_types<tuple, 0>::type(),
>                __t...
>               ) {}
>
>    template <class _Alloc>
>      __attribute__ ((__visibility__("hidden"), __always_inline__))
>      tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
>        : base_(allocator_arg_t(), __a,
>                typename __make_tuple_indices<sizeof...(_Tp)>::type(),
>                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
>                typename __make_tuple_indices<0>::type(),
>                typename __make_tuple_types<tuple, 0>::type(),
>                __t...
>               ) {}
>
>    template <class ..._Up,
>              typename enable_if
>                      <
>                         sizeof...(_Up) <= sizeof...(_Tp) &&
>                         __tuple_convertible
>                         <
>                            tuple<_Up...>,
>                            typename __make_tuple_types<tuple,
>                                     sizeof...(_Up) < sizeof...(_Tp) ?
>                                        sizeof...(_Up) :
>                                        sizeof...(_Tp)>::type
>                         >::value,
>                         bool
>                      >::type = false
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(_Up&&... __u)
>           
>            : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
>                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
>                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
>                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
>                    std::__1::forward<_Up>(__u)...) {}
>
>    template <class ..._Up,
>              typename enable_if
>                      <
>                         sizeof...(_Up) <= sizeof...(_Tp) &&
>                         __tuple_constructible
>                         <
>                            tuple<_Up...>,
>                            typename __make_tuple_types<tuple,
>                                     sizeof...(_Up) < sizeof...(_Tp) ?
>                                        sizeof...(_Up) :
>                                        sizeof...(_Tp)>::type
>                         >::value &&
>                         !__tuple_convertible
>                         <
>                            tuple<_Up...>,
>                            typename __make_tuple_types<tuple,
>                                     sizeof...(_Up) < sizeof...(_Tp) ?
>                                        sizeof...(_Up) :
>                                        sizeof...(_Tp)>::type
>                         >::value,
>                         bool
>                      >::type =false
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit
>        tuple(_Up&&... __u)
>           
>            : base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
>                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
>                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
>                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
>                    std::__1::forward<_Up>(__u)...) {}
>
>    template <class _Alloc, class ..._Up,
>              class = typename enable_if
>                      <
>                         sizeof...(_Up) <= sizeof...(_Tp) &&
>                         __tuple_convertible
>                         <
>                            tuple<_Up...>,
>                            typename __make_tuple_types<tuple,
>                                     sizeof...(_Up) < sizeof...(_Tp) ?
>                                        sizeof...(_Up) :
>                                        sizeof...(_Tp)>::type
>                         >::value
>                      >::type
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
>            : base_(allocator_arg_t(), __a,
>                    typename __make_tuple_indices<sizeof...(_Up)>::type(),
>                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
>                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
>                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
>                    std::__1::forward<_Up>(__u)...) {}
>
>    template <class _Tuple,
>              typename enable_if
>                      <
>                         __tuple_convertible<_Tuple, tuple>::value,
>                         bool
>                      >::type = false
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(_Tuple&& __t)
>            : base_(std::__1::forward<_Tuple>(__t)) {}
>
>    template <class _Tuple,
>              typename enable_if
>                      <
>                         __tuple_constructible<_Tuple, tuple>::value &&
>                         !__tuple_convertible<_Tuple, tuple>::value,
>                         bool
>                      >::type = false
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        explicit
>        tuple(_Tuple&& __t)
>            : base_(std::__1::forward<_Tuple>(__t)) {}
>
>    template <class _Alloc, class _Tuple,
>              class = typename enable_if
>                      <
>                         __tuple_convertible<_Tuple, tuple>::value
>                      >::type
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
>            : base_(allocator_arg_t(), __a, std::__1::forward<_Tuple>(__t)) {}
>
>    template <class _Tuple,
>              class = typename enable_if
>                      <
>                         __tuple_assignable<_Tuple, tuple>::value
>                      >::type
>             >
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple&
>        operator=(_Tuple&& __t)
>        {
>            base_.operator=(std::__1::forward<_Tuple>(__t));
>            return *this;
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void swap(tuple& __t)
>        {base_.swap(__t.base_);}
>};
>
>template <>
>class __attribute__ ((__visibility__("default"))) tuple<>
>{
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    constexpr tuple() throw() {}
>    template <class _Alloc>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(allocator_arg_t, const _Alloc&) throw() {}
>    template <class _Alloc>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(allocator_arg_t, const _Alloc&, const tuple&) throw() {}
>    template <class _Up>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(array<_Up, 0>) throw() {}
>    template <class _Alloc, class _Up>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) throw() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void swap(tuple&) throw() {}
>};
>
>template <class ..._Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    __all<__is_swappable<_Tp>::value...>::value,
>    void
>>::type
>swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
>                
>    {__t.swap(__u);}
>
>
>
>template <size_t _Ip, class ..._Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, tuple<_Tp...> >::type&
>get(tuple<_Tp...>& __t) throw()
>{
>    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
>    return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
>}
>
>template <size_t _Ip, class ..._Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>const typename tuple_element<_Ip, tuple<_Tp...> >::type&
>get(const tuple<_Tp...>& __t) throw()
>{
>    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
>    return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
>}
>
>template <size_t _Ip, class ..._Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename tuple_element<_Ip, tuple<_Tp...> >::type&&
>get(tuple<_Tp...>&& __t) throw()
>{
>    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
>    return static_cast<type&&>(
>             static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
>}
>template <class ..._Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>tuple<_Tp&...>
>tie(_Tp&... __t) throw()
>{
>    return tuple<_Tp&...>(__t...);
>}
>
>template <class _Up>
>struct __ignore_t
>{
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        const __ignore_t& operator=(_Tp&&) const {return *this;}
>};
>
>namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); }
>
>template <class _Tp> class __attribute__ ((__visibility__("default"))) reference_wrapper;
>
>template <class _Tp>
>struct __make_tuple_return_impl
>{
>    typedef _Tp type;
>};
>
>template <class _Tp>
>struct __make_tuple_return_impl<reference_wrapper<_Tp> >
>{
>    typedef _Tp& type;
>};
>
>template <class _Tp>
>struct __make_tuple_return
>{
>    typedef typename __make_tuple_return_impl<typename decay<_Tp>::type>::type type;
>};
>
>template <class... _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>tuple<typename __make_tuple_return<_Tp>::type...>
>make_tuple(_Tp&&... __t)
>{
>    return tuple<typename __make_tuple_return<_Tp>::type...>(std::__1::forward<_Tp>(__t)...);
>}
>
>template <class... _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>tuple<_Tp&&...>
>forward_as_tuple(_Tp&&... __t) throw()
>{
>    return tuple<_Tp&&...>(std::__1::forward<_Tp>(__t)...);
>}
>
>template <size_t _Ip>
>struct __tuple_equal
>{
>    template <class _Tp, class _Up>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _Tp& __x, const _Up& __y)
>    {
>        return __tuple_equal<_Ip - 1>()(__x, __y) && get<_Ip-1>(__x) == get<_Ip-1>(__y);
>    }
>};
>
>template <>
>struct __tuple_equal<0>
>{
>    template <class _Tp, class _Up>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _Tp&, const _Up&)
>    {
>        return true;
>    }
>};
>
>template <class ..._Tp, class ..._Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
>{
>    return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
>}
>
>template <class ..._Tp, class ..._Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
>{
>    return !(__x == __y);
>}
>
>template <size_t _Ip>
>struct __tuple_less
>{
>    template <class _Tp, class _Up>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _Tp& __x, const _Up& __y)
>    {
>        return __tuple_less<_Ip-1>()(__x, __y) ||
>             (!__tuple_less<_Ip-1>()(__y, __x) && get<_Ip-1>(__x) < get<_Ip-1>(__y));
>    }
>};
>
>template <>
>struct __tuple_less<0>
>{
>    template <class _Tp, class _Up>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _Tp&, const _Up&)
>    {
>        return false;
>    }
>};
>
>template <class ..._Tp, class ..._Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
>{
>    return __tuple_less<sizeof...(_Tp)>()(__x, __y);
>}
>
>template <class ..._Tp, class ..._Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
>{
>    return __y < __x;
>}
>
>template <class ..._Tp, class ..._Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
>{
>    return !(__x < __y);
>}
>
>template <class ..._Tp, class ..._Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
>{
>    return !(__y < __x);
>}
>
>
>
>template <class _Tp, class _Up> struct __tuple_cat_type;
>
>template <class ..._Ttypes, class ..._Utypes>
>struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
>{
>    typedef tuple<_Ttypes..., _Utypes...> type;
>};
>
>template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
>struct __tuple_cat_return_1
>{
>};
>
>template <class ..._Types, class _Tuple0>
>struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
>{
>    typedef typename __tuple_cat_type<tuple<_Types...>,
>            typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
>                                                                           type;
>};
>
>template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
>struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
>    : public __tuple_cat_return_1<
>                 typename __tuple_cat_type<
>                     tuple<_Types...>,
>                     typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
>                 >::type,
>                 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
>                 _Tuple1, _Tuples...>
>{
>};
>
>template <class ..._Tuples> struct __tuple_cat_return;
>
>template <class _Tuple0, class ..._Tuples>
>struct __tuple_cat_return<_Tuple0, _Tuples...>
>    : public __tuple_cat_return_1<tuple<>,
>         __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
>                                                                     _Tuples...>
>{
>};
>
>template <>
>struct __tuple_cat_return<>
>{
>    typedef tuple<> type;
>};
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>tuple<>
>tuple_cat()
>{
>    return tuple<>();
>}
>
>template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
>struct __tuple_cat_return_ref_imp;
>
>template <class ..._Types, size_t ..._I0, class _Tuple0>
>struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
>{
>    typedef typename remove_reference<_Tuple0>::type _T0;
>    typedef tuple<_Types..., typename __apply_cv<_Tuple0,
>                          typename tuple_element<_I0, _T0>::type>::type&&...> type;
>};
>
>template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
>struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
>                                  _Tuple0, _Tuple1, _Tuples...>
>    : public __tuple_cat_return_ref_imp<
>         tuple<_Types..., typename __apply_cv<_Tuple0,
>               typename tuple_element<_I0,
>                  typename remove_reference<_Tuple0>::type>::type>::type&&...>,
>         typename __make_tuple_indices<tuple_size<typename
>                                 remove_reference<_Tuple1>::type>::value>::type,
>         _Tuple1, _Tuples...>
>{
>};
>
>template <class _Tuple0, class ..._Tuples>
>struct __tuple_cat_return_ref
>    : public __tuple_cat_return_ref_imp<tuple<>,
>               typename __make_tuple_indices<
>                        tuple_size<typename remove_reference<_Tuple0>::type>::value
>               >::type, _Tuple0, _Tuples...>
>{
>};
>
>template <class _Types, class _I0, class _J0>
>struct __tuple_cat;
>
>template <class ..._Types, size_t ..._I0, size_t ..._J0>
>struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
>{
>    template <class _Tuple0>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
>    operator()(tuple<_Types...> __t, _Tuple0&& __t0)
>    {
>        return forward_as_tuple(std::__1::forward<_Types>(get<_I0>(__t))...,
>                                      get<_J0>(std::__1::forward<_Tuple0>(__t0))...);
>    }
>
>    template <class _Tuple0, class _Tuple1, class ..._Tuples>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
>    operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
>    {
>        typedef typename remove_reference<_Tuple0>::type _T0;
>        typedef typename remove_reference<_Tuple1>::type _T1;
>        return __tuple_cat<
>           tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
>           typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
>           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
>                           (forward_as_tuple(
>                              std::__1::forward<_Types>(get<_I0>(__t))...,
>                              get<_J0>(std::__1::forward<_Tuple0>(__t0))...
>                            ),
>                            std::__1::forward<_Tuple1>(__t1),
>                            std::__1::forward<_Tuples>(__tpls)...);
>    }
>};
>
>template <class _Tuple0, class... _Tuples>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename __tuple_cat_return<_Tuple0, _Tuples...>::type
>tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
>{
>    typedef typename remove_reference<_Tuple0>::type _T0;
>    return __tuple_cat<tuple<>, __tuple_indices<>,
>                  typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
>                  (tuple<>(), std::__1::forward<_Tuple0>(__t0),
>                                            std::__1::forward<_Tuples>(__tpls)...);
>}
>
>template <class ..._Tp, class _Alloc>
>struct __attribute__ ((__visibility__("default"))) uses_allocator<tuple<_Tp...>, _Alloc>
>    : true_type {};
>
>template <class _T1, class _T2>
>template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<_T1, _T2>::pair(piecewise_construct_t,
>                     tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
>                     __tuple_indices<_I1...>, __tuple_indices<_I2...>)
>    : first(std::__1::forward<_Args1>(get<_I1>( __first_args))...),
>      second(std::__1::forward<_Args2>(get<_I2>(__second_args))...)
>{
>}
>
>
>
>} }
>       
>
>
>namespace std { namespace __1 {
>
>using ::size_t;
>using ::memcpy;
>using ::memmove;
>using ::strcpy;
>using ::strncpy;
>using ::strcat;
>using ::strncat;
>using ::memcmp;
>using ::strcmp;
>using ::strncmp;
>using ::strcoll;
>using ::strxfrm;
>
>using ::memchr;
>
>using ::strchr;
>
>using ::strcspn;
>
>using ::strpbrk;
>
>using ::strrchr;
>
>using ::strspn;
>
>using ::strstr;
>
>
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) char* strchr( char* __s, int __c) {return ::strchr(__s, __c);}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) char* strpbrk( char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) char* strrchr( char* __s, int __c) {return ::strrchr(__s, __c);}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void* memchr( void* __s, int __c, size_t __n) {return ::memchr(__s, __c, __n);}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) char* strstr( char* __s1, const char* __s2) {return ::strstr(__s1, __s2);}
>
>
>using ::strtok;
>using ::memset;
>using ::strerror;
>using ::strlen;
>
>} }
>
>
>       
>
>
>namespace std { namespace __1 {
>
>
>
>template <class _Tp> class allocator;
>
>template <>
>class __attribute__ ((__visibility__("default"))) allocator<void>
>{
>public:
>    typedef void* pointer;
>    typedef const void* const_pointer;
>    typedef void value_type;
>
>    template <class _Up> struct rebind {typedef allocator<_Up> other;};
>};
>
>template <>
>class __attribute__ ((__visibility__("default"))) allocator<const void>
>{
>public:
>    typedef const void* pointer;
>    typedef const void* const_pointer;
>    typedef const void value_type;
>
>    template <class _Up> struct rebind {typedef allocator<_Up> other;};
>};
>
>
>
>template <class _Tp>
>struct __has_element_type
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::element_type* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Ptr, bool = __has_element_type<_Ptr>::value>
>struct __pointer_traits_element_type;
>
>template <class _Ptr>
>struct __pointer_traits_element_type<_Ptr, true>
>{
>    typedef typename _Ptr::element_type type;
>};
>
>
>
>template <template <class, class...> class _Sp, class _Tp, class ..._Args>
>struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
>{
>    typedef typename _Sp<_Tp, _Args...>::element_type type;
>};
>
>template <template <class, class...> class _Sp, class _Tp, class ..._Args>
>struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
>{
>    typedef _Tp type;
>};
>template <class _Tp>
>struct __has_difference_type
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::difference_type* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
>struct __pointer_traits_difference_type
>{
>    typedef ptrdiff_t type;
>};
>
>template <class _Ptr>
>struct __pointer_traits_difference_type<_Ptr, true>
>{
>    typedef typename _Ptr::difference_type type;
>};
>
>template <class _Tp, class _Up>
>struct __has_rebind
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Xp> static __two __test(...);
>    template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
>struct __pointer_traits_rebind
>{
>
>
>
>    typedef typename _Tp::template rebind<_Up>::other type;
>
>};
>
>
>
>template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
>struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
>{
>
>
>
>    typedef typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
>
>};
>
>template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
>struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
>{
>    typedef _Sp<_Up, _Args...> type;
>};
>template <class _Ptr>
>struct __attribute__ ((__visibility__("default"))) pointer_traits
>{
>    typedef _Ptr pointer;
>    typedef typename __pointer_traits_element_type<pointer>::type element_type;
>    typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
>
>
>
>
>    template <class _Up> struct rebind
>        {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
>
>
>private:
>    struct __nat {};
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static pointer pointer_to(typename conditional<is_void<element_type>::value,
>                                           __nat, element_type>::type& __r)
>        {return pointer::pointer_to(__r);}
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) pointer_traits<_Tp*>
>{
>    typedef _Tp* pointer;
>    typedef _Tp element_type;
>    typedef ptrdiff_t difference_type;
>
>
>
>
>    template <class _Up> struct rebind {typedef _Up* other;};
>
>
>private:
>    struct __nat {};
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static pointer pointer_to(typename conditional<is_void<element_type>::value,
>                                      __nat, element_type>::type& __r) throw()
>        {return std::__1::addressof(__r);}
>};
>
>
>
>namespace __has_pointer_type_imp
>{
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::pointer* = 0);
>}
>
>template <class _Tp>
>struct __has_pointer_type
>    : public integral_constant<bool, sizeof(__has_pointer_type_imp::__test<_Tp>(0)) == 1>
>{
>};
>
>namespace __pointer_type_imp
>{
>
>template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value>
>struct __pointer_type
>{
>    typedef typename _Dp::pointer type;
>};
>
>template <class _Tp, class _Dp>
>struct __pointer_type<_Tp, _Dp, false>
>{
>    typedef _Tp* type;
>};
>
>}
>
>template <class _Tp, class _Dp>
>struct __pointer_type
>{
>    typedef typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type;
>};
>
>template <class _Tp>
>struct __has_const_pointer
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::const_pointer* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value>
>struct __const_pointer
>{
>    typedef typename _Alloc::const_pointer type;
>};
>
>template <class _Tp, class _Ptr, class _Alloc>
>struct __const_pointer<_Tp, _Ptr, _Alloc, false>
>{
>
>
>
>    typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type;
>
>};
>
>template <class _Tp>
>struct __has_void_pointer
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::void_pointer* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value>
>struct __void_pointer
>{
>    typedef typename _Alloc::void_pointer type;
>};
>
>template <class _Ptr, class _Alloc>
>struct __void_pointer<_Ptr, _Alloc, false>
>{
>
>
>
>    typedef typename pointer_traits<_Ptr>::template rebind<void>::other type;
>
>};
>
>template <class _Tp>
>struct __has_const_void_pointer
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::const_void_pointer* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
>struct __const_void_pointer
>{
>    typedef typename _Alloc::const_void_pointer type;
>};
>
>template <class _Ptr, class _Alloc>
>struct __const_void_pointer<_Ptr, _Alloc, false>
>{
>
>
>
>    typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type;
>
>};
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp*
>__to_raw_pointer(_Tp* __p) throw()
>{
>    return __p;
>}
>
>template <class _Pointer>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename pointer_traits<_Pointer>::element_type*
>__to_raw_pointer(_Pointer __p) throw()
>{
>    return std::__1::__to_raw_pointer(__p.operator->());
>}
>
>template <class _Tp>
>struct __has_size_type
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::size_type* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
>struct __size_type
>{
>    typedef typename make_unsigned<_DiffType>::type type;
>};
>
>template <class _Alloc, class _DiffType>
>struct __size_type<_Alloc, _DiffType, true>
>{
>    typedef typename _Alloc::size_type type;
>};
>
>template <class _Tp>
>struct __has_propagate_on_container_copy_assignment
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::propagate_on_container_copy_assignment* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value>
>struct __propagate_on_container_copy_assignment
>{
>    typedef false_type type;
>};
>
>template <class _Alloc>
>struct __propagate_on_container_copy_assignment<_Alloc, true>
>{
>    typedef typename _Alloc::propagate_on_container_copy_assignment type;
>};
>
>template <class _Tp>
>struct __has_propagate_on_container_move_assignment
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::propagate_on_container_move_assignment* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
>struct __propagate_on_container_move_assignment
>{
>    typedef false_type type;
>};
>
>template <class _Alloc>
>struct __propagate_on_container_move_assignment<_Alloc, true>
>{
>    typedef typename _Alloc::propagate_on_container_move_assignment type;
>};
>
>template <class _Tp>
>struct __has_propagate_on_container_swap
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Up> static __two __test(...);
>    template <class _Up> static char __test(typename _Up::propagate_on_container_swap* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
>struct __propagate_on_container_swap
>{
>    typedef false_type type;
>};
>
>template <class _Alloc>
>struct __propagate_on_container_swap<_Alloc, true>
>{
>    typedef typename _Alloc::propagate_on_container_swap type;
>};
>
>template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
>struct __has_rebind_other
>{
>private:
>    struct __two {char __lx; char __lxx;};
>    template <class _Xp> static __two __test(...);
>    template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0);
>public:
>    static const bool value = sizeof(__test<_Tp>(0)) == 1;
>};
>
>template <class _Tp, class _Up>
>struct __has_rebind_other<_Tp, _Up, false>
>{
>    static const bool value = false;
>};
>
>template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
>struct __allocator_traits_rebind
>{
>    typedef typename _Tp::template rebind<_Up>::other type;
>};
>
>
>
>template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
>struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>
>{
>    typedef typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type;
>};
>
>template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
>struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>
>{
>    typedef _Alloc<_Up, _Args...> type;
>};
>template <class _Alloc, class _SizeType, class _ConstVoidPtr>
>auto
>__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
>    -> decltype(__a.allocate(__sz, __p), true_type());
>
>template <class _Alloc, class _SizeType, class _ConstVoidPtr>
>auto
>__has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
>    -> false_type;
>
>template <class _Alloc, class _SizeType, class _ConstVoidPtr>
>struct __has_allocate_hint
>    : integral_constant<bool,
>        is_same<
>            decltype(__has_allocate_hint_test(declval<_Alloc>(),
>                                          declval<_SizeType>(),
>                                          declval<_ConstVoidPtr>())),
>            true_type>::value>
>{
>};
>template <class _Alloc, class _Tp, class ..._Args>
>decltype(std::__1::declval<_Alloc>().construct(std::__1::declval<_Tp*>(),
>                                           std::__1::declval<_Args>()...),
>                                           true_type())
>__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);
>
>template <class _Alloc, class _Pointer, class ..._Args>
>false_type
>__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args);
>
>template <class _Alloc, class _Pointer, class ..._Args>
>struct __has_construct
>    : integral_constant<bool,
>        is_same<
>            decltype(__has_construct_test(declval<_Alloc>(),
>                                          declval<_Pointer>(),
>                                          declval<_Args>()...)),
>            true_type>::value>
>{
>};
>
>template <class _Alloc, class _Pointer>
>auto
>__has_destroy_test(_Alloc&& __a, _Pointer&& __p)
>    -> decltype(__a.destroy(__p), true_type());
>
>template <class _Alloc, class _Pointer>
>auto
>__has_destroy_test(const _Alloc& __a, _Pointer&& __p)
>    -> false_type;
>
>template <class _Alloc, class _Pointer>
>struct __has_destroy
>    : integral_constant<bool,
>        is_same<
>            decltype(__has_destroy_test(declval<_Alloc>(),
>                                        declval<_Pointer>())),
>            true_type>::value>
>{
>};
>
>template <class _Alloc>
>auto
>__has_max_size_test(_Alloc&& __a)
>    -> decltype(__a.max_size(), true_type());
>
>template <class _Alloc>
>auto
>__has_max_size_test(const volatile _Alloc& __a)
>    -> false_type;
>
>template <class _Alloc>
>struct __has_max_size
>    : integral_constant<bool,
>        is_same<
>            decltype(__has_max_size_test(declval<_Alloc&>())),
>            true_type>::value>
>{
>};
>
>template <class _Alloc>
>auto
>__has_select_on_container_copy_construction_test(_Alloc&& __a)
>    -> decltype(__a.select_on_container_copy_construction(), true_type());
>
>template <class _Alloc>
>auto
>__has_select_on_container_copy_construction_test(const volatile _Alloc& __a)
>    -> false_type;
>
>template <class _Alloc>
>struct __has_select_on_container_copy_construction
>    : integral_constant<bool,
>        is_same<
>            decltype(__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
>            true_type>::value>
>{
>};
>template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value>
>struct __alloc_traits_difference_type
>{
>    typedef typename pointer_traits<_Ptr>::difference_type type;
>};
>
>template <class _Alloc, class _Ptr>
>struct __alloc_traits_difference_type<_Alloc, _Ptr, true>
>{
>    typedef typename _Alloc::difference_type type;
>};
>
>template <class _Alloc>
>struct __attribute__ ((__visibility__("default"))) allocator_traits
>{
>    typedef _Alloc allocator_type;
>    typedef typename allocator_type::value_type value_type;
>
>    typedef typename __pointer_type<value_type, allocator_type>::type pointer;
>    typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer;
>    typedef typename __void_pointer<pointer, allocator_type>::type void_pointer;
>    typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer;
>
>    typedef typename __alloc_traits_difference_type<allocator_type, pointer>::type difference_type;
>    typedef typename __size_type<allocator_type, difference_type>::type size_type;
>
>    typedef typename __propagate_on_container_copy_assignment<allocator_type>::type
>                     propagate_on_container_copy_assignment;
>    typedef typename __propagate_on_container_move_assignment<allocator_type>::type
>                     propagate_on_container_move_assignment;
>    typedef typename __propagate_on_container_swap<allocator_type>::type
>                     propagate_on_container_swap;
>
>
>
>
>
>
>    template <class _Tp> struct rebind_alloc
>        {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;};
>    template <class _Tp> struct rebind_traits
>        {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;};
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static pointer allocate(allocator_type& __a, size_type __n)
>        {return __a.allocate(__n);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
>        {return allocate(__a, __n, __hint,
>            __has_allocate_hint<allocator_type, size_type, const_void_pointer>());}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static void deallocate(allocator_type& __a, pointer __p, size_type __n) throw()
>        {__a.deallocate(__p, __n);}
>
>
>    template <class _Tp, class... _Args>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
>            {__construct(__has_construct<allocator_type, pointer, _Args...>(),
>                         __a, __p, std::__1::forward<_Args>(__args)...);}
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static void destroy(allocator_type& __a, _Tp* __p)
>            {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static size_type max_size(const allocator_type& __a) throw()
>        {return __max_size(__has_max_size<const allocator_type>(), __a);}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static allocator_type
>        select_on_container_copy_construction(const allocator_type& __a)
>            {return select_on_container_copy_construction(
>                __has_select_on_container_copy_construction<const allocator_type>(),
>                __a);}
>
>    template <class _Ptr>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static
>        void
>        __construct_forward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2)
>        {
>            for (; __begin1 != __end1; ++__begin1, ++__begin2)
>                construct(__a, std::__1::__to_raw_pointer(__begin2), std::__1::move_if_noexcept(*__begin1));
>        }
>
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static
>        typename enable_if
>        <
>            (is_same<allocator_type, allocator<_Tp> >::value
>                || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
>             is_trivially_move_constructible<_Tp>::value,
>            void
>        >::type
>        __construct_forward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
>        {
>            ptrdiff_t _Np = __end1 - __begin1;
>            std::__1::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
>            __begin2 += _Np;
>        }
>
>    template <class _Ptr>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static
>        void
>        __construct_backward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2)
>        {
>            while (__end1 != __begin1)
>            {
>                construct(__a, std::__1::__to_raw_pointer(__end2-1), std::__1::move_if_noexcept(*--__end1));
>                --__end2;
>            }
>        }
>
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static
>        typename enable_if
>        <
>            (is_same<allocator_type, allocator<_Tp> >::value
>                || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
>             is_trivially_move_constructible<_Tp>::value,
>            void
>        >::type
>        __construct_backward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)
>        {
>            ptrdiff_t _Np = __end1 - __begin1;
>            __end2 -= _Np;
>            std::__1::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
>        }
>
>private:
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static pointer allocate(allocator_type& __a, size_type __n,
>        const_void_pointer __hint, true_type)
>        {return __a.allocate(__n, __hint);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static pointer allocate(allocator_type& __a, size_type __n,
>        const_void_pointer, false_type)
>        {return __a.allocate(__n);}
>
>
>    template <class _Tp, class... _Args>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
>            {__a.construct(__p, std::__1::forward<_Args>(__args)...);}
>    template <class _Tp, class... _Args>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
>            {
>                ::new ((void*)__p) _Tp(std::__1::forward<_Args>(__args)...);
>            }
>
>
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static void __destroy(true_type, allocator_type& __a, _Tp* __p)
>            {__a.destroy(__p);}
>    template <class _Tp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        static void __destroy(false_type, allocator_type&, _Tp* __p)
>            {
>                __p->~_Tp();
>            }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static size_type __max_size(true_type, const allocator_type& __a)
>            {return __a.max_size();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static size_type __max_size(false_type, const allocator_type&)
>            {return numeric_limits<size_type>::max();}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static allocator_type
>        select_on_container_copy_construction(true_type, const allocator_type& __a)
>            {return __a.select_on_container_copy_construction();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static allocator_type
>        select_on_container_copy_construction(false_type, const allocator_type& __a)
>            {return __a;}
>};
>
>
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) 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;
>
>    typedef true_type propagate_on_container_move_assignment;
>
>    template <class _Up> struct rebind {typedef allocator<_Up> other;};
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) allocator() throw() {}
>    template <class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) allocator(const allocator<_Up>&) throw() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer address(reference __x) const throw()
>        {return std::__1::addressof(__x);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) const_pointer address(const_reference __x) const throw()
>        {return std::__1::addressof(__x);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
>        {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void deallocate(pointer __p, size_type) throw()
>        {::operator delete((void*)__p);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) size_type max_size() const throw()
>        {return size_type(~0) / sizeof(_Tp);}
>
>    template <class _Up, class... _Args>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        void
>        construct(_Up* __p, _Args&&... __args)
>        {
>            ::new((void*)__p) _Up(std::__1::forward<_Args>(__args)...);
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void destroy(pointer __p) {__p->~_Tp();}
>};
>
>template <class _Tp>
>class __attribute__ ((__visibility__("default"))) allocator<const _Tp>
>{
>public:
>    typedef size_t size_type;
>    typedef ptrdiff_t difference_type;
>    typedef const _Tp* pointer;
>    typedef const _Tp* const_pointer;
>    typedef const _Tp& reference;
>    typedef const _Tp& const_reference;
>    typedef const _Tp value_type;
>
>    typedef true_type propagate_on_container_move_assignment;
>
>    template <class _Up> struct rebind {typedef allocator<_Up> other;};
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) allocator() throw() {}
>    template <class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) allocator(const allocator<_Up>&) throw() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) const_pointer address(const_reference __x) const throw()
>        {return std::__1::addressof(__x);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
>        {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void deallocate(pointer __p, size_type) throw()
>        {::operator delete((void*)__p);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) size_type max_size() const throw()
>        {return size_type(~0) / sizeof(_Tp);}
>
>    template <class _Up, class... _Args>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        void
>        construct(_Up* __p, _Args&&... __args)
>        {
>            ::new((void*)__p) _Up(std::__1::forward<_Args>(__args)...);
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void destroy(pointer __p) {__p->~_Tp();}
>};
>
>template <class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool operator==(const allocator<_Tp>&, const allocator<_Up>&) throw() {return true;}
>
>template <class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) throw() {return false;}
>
>template <class _OutputIterator, class _Tp>
>class __attribute__ ((__visibility__("default"))) raw_storage_iterator
>    : public iterator<output_iterator_tag,
>                      _Tp,
>                      ptrdiff_t,
>                      _Tp*,
>                      raw_storage_iterator<_OutputIterator, _Tp>&>
>{
>private:
>    _OutputIterator __x_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) raw_storage_iterator& operator*() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) raw_storage_iterator& operator=(const _Tp& __element)
>        {::new(&*__x_) _Tp(__element); return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) raw_storage_iterator& operator++() {++__x_; return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) raw_storage_iterator operator++(int)
>        {raw_storage_iterator __t(*this); ++__x_; return __t;}
>};
>
>template <class _Tp>
>pair<_Tp*, ptrdiff_t>
>get_temporary_buffer(ptrdiff_t __n) throw()
>{
>    pair<_Tp*, ptrdiff_t> __r(0, 0);
>    const ptrdiff_t __m = (~ptrdiff_t(0) ^
>                           ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * 8 - 1)))
>                           / sizeof(_Tp);
>    if (__n > __m)
>        __n = __m;
>    while (__n > 0)
>    {
>        __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow));
>        if (__r.first)
>        {
>            __r.second = __n;
>            break;
>        }
>        __n /= 2;
>    }
>    return __r;
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void return_temporary_buffer(_Tp* __p) throw() {::operator delete(__p);}
>
>template <class _Tp>
>struct auto_ptr_ref
>{
>    _Tp* __ptr_;
>};
>
>template<class _Tp>
>class __attribute__ ((__visibility__("default"))) auto_ptr
>{
>private:
>    _Tp* __ptr_;
>public:
>    typedef _Tp element_type;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {}
>    template<class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) auto_ptr(auto_ptr<_Up>& __p) throw()
>        : __ptr_(__p.release()) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) auto_ptr& operator=(auto_ptr& __p) throw()
>        {reset(__p.release()); return *this;}
>    template<class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) auto_ptr& operator=(auto_ptr<_Up>& __p) throw()
>        {reset(__p.release()); return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) auto_ptr& operator=(auto_ptr_ref<_Tp> __p) throw()
>        {reset(__p.__ptr_); return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ~auto_ptr() throw() {delete __ptr_;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Tp& operator*() const throw()
>        {return *__ptr_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Tp* operator->() const throw() {return __ptr_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Tp* get() const throw() {return __ptr_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Tp* release() throw()
>    {
>        _Tp* __t = __ptr_;
>        __ptr_ = 0;
>        return __t;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void reset(_Tp* __p = 0) throw()
>    {
>        if (__ptr_ != __p)
>            delete __ptr_;
>        __ptr_ = __p;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {}
>    template<class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) operator auto_ptr_ref<_Up>() throw()
>        {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}
>    template<class _Up> __attribute__ ((__visibility__("hidden"), __always_inline__)) operator auto_ptr<_Up>() throw()
>        {return auto_ptr<_Up>(release());}
>};
>
>template <>
>class __attribute__ ((__visibility__("default"))) auto_ptr<void>
>{
>public:
>    typedef void element_type;
>};
>
>template <class _T1, class _T2, bool = is_same<typename remove_cv<_T1>::type,
>                                                     typename remove_cv<_T2>::type>::value,
>                                bool = is_empty<_T1>::value
>
>
>
>                                ,
>                                bool = is_empty<_T2>::value
>
>
>
>         >
>struct __libcpp_compressed_pair_switch;
>
>template <class _T1, class _T2, bool IsSame>
>struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, false, false> {enum {value = 0};};
>
>template <class _T1, class _T2, bool IsSame>
>struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, true, false> {enum {value = 1};};
>
>template <class _T1, class _T2, bool IsSame>
>struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, false, true> {enum {value = 2};};
>
>template <class _T1, class _T2>
>struct __libcpp_compressed_pair_switch<_T1, _T2, false, true, true> {enum {value = 3};};
>
>template <class _T1, class _T2>
>struct __libcpp_compressed_pair_switch<_T1, _T2, true, true, true> {enum {value = 1};};
>
>template <class _T1, class _T2, unsigned = __libcpp_compressed_pair_switch<_T1, _T2>::value>
>class __libcpp_compressed_pair_imp;
>
>template <class _T1, class _T2>
>class __libcpp_compressed_pair_imp<_T1, _T2, 0>
>{
>private:
>    _T1 __first_;
>    _T2 __second_;
>public:
>    typedef _T1 _T1_param;
>    typedef _T2 _T2_param;
>
>    typedef typename remove_reference<_T1>::type& _T1_reference;
>    typedef typename remove_reference<_T2>::type& _T2_reference;
>
>    typedef const typename remove_reference<_T1>::type& _T1_const_reference;
>    typedef const typename remove_reference<_T2>::type& _T2_const_reference;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T1_param __t1)
>        : __first_(std::__1::forward<_T1_param>(__t1)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T2_param __t2)
>        : __second_(std::__1::forward<_T2_param>(__t2)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
>        : __first_(std::__1::forward<_T1_param>(__t1)), __second_(std::__1::forward<_T2_param>(__t2)) {}
>    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
>                                     tuple<_Args1...> __first_args,
>                                     tuple<_Args2...> __second_args,
>                                     __tuple_indices<_I1...>,
>                                     __tuple_indices<_I2...>)
>            : __first_(std::__1::forward<_Args1>(get<_I1>(__first_args))...),
>              __second_(std::__1::forward<_Args2>(get<_I2>(__second_args))...)
>            {}
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_reference first() throw() {return __first_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_const_reference first() const throw() {return __first_;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_reference second() throw() {return __second_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_const_reference second() const throw() {return __second_;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void swap(__libcpp_compressed_pair_imp& __x)
>       
>
>    {
>        using std::__1::swap;
>        swap(__first_, __x.__first_);
>        swap(__second_, __x.__second_);
>    }
>};
>
>template <class _T1, class _T2>
>class __libcpp_compressed_pair_imp<_T1, _T2, 1>
>    : private _T1
>{
>private:
>    _T2 __second_;
>public:
>    typedef _T1 _T1_param;
>    typedef _T2 _T2_param;
>
>    typedef _T1& _T1_reference;
>    typedef typename remove_reference<_T2>::type& _T2_reference;
>
>    typedef const _T1& _T1_const_reference;
>    typedef const typename remove_reference<_T2>::type& _T2_const_reference;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T1_param __t1)
>        : _T1(std::__1::forward<_T1_param>(__t1)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T2_param __t2)
>        : __second_(std::__1::forward<_T2_param>(__t2)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
>        : _T1(std::__1::forward<_T1_param>(__t1)), __second_(std::__1::forward<_T2_param>(__t2)) {}
>    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
>                                     tuple<_Args1...> __first_args,
>                                     tuple<_Args2...> __second_args,
>                                     __tuple_indices<_I1...>,
>                                     __tuple_indices<_I2...>)
>            : _T1(std::__1::forward<_Args1>(get<_I1>(__first_args))...),
>              __second_(std::__1::forward<_Args2>(get<_I2>(__second_args))...)
>            {}
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_reference first() throw() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_const_reference first() const throw() {return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_reference second() throw() {return __second_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_const_reference second() const throw() {return __second_;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void swap(__libcpp_compressed_pair_imp& __x)
>       
>
>    {
>        using std::__1::swap;
>        swap(__second_, __x.__second_);
>    }
>};
>
>template <class _T1, class _T2>
>class __libcpp_compressed_pair_imp<_T1, _T2, 2>
>    : private _T2
>{
>private:
>    _T1 __first_;
>public:
>    typedef _T1 _T1_param;
>    typedef _T2 _T2_param;
>
>    typedef typename remove_reference<_T1>::type& _T1_reference;
>    typedef _T2& _T2_reference;
>
>    typedef const typename remove_reference<_T1>::type& _T1_const_reference;
>    typedef const _T2& _T2_const_reference;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T1_param __t1)
>        : __first_(std::__1::forward<_T1_param>(__t1)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T2_param __t2)
>        : _T2(std::__1::forward<_T2_param>(__t2)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
>       
>
>        : _T2(std::__1::forward<_T2_param>(__t2)), __first_(std::__1::forward<_T1_param>(__t1)) {}
>    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
>                                     tuple<_Args1...> __first_args,
>                                     tuple<_Args2...> __second_args,
>                                     __tuple_indices<_I1...>,
>                                     __tuple_indices<_I2...>)
>            : _T2(std::__1::forward<_Args2>(get<_I2>(__second_args))...),
>              __first_(std::__1::forward<_Args1>(get<_I1>(__first_args))...)
>
>            {}
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_reference first() throw() {return __first_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_const_reference first() const throw() {return __first_;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_reference second() throw() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_const_reference second() const throw() {return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void swap(__libcpp_compressed_pair_imp& __x)
>       
>
>    {
>        using std::__1::swap;
>        swap(__first_, __x.__first_);
>    }
>};
>
>template <class _T1, class _T2>
>class __libcpp_compressed_pair_imp<_T1, _T2, 3>
>    : private _T1,
>      private _T2
>{
>public:
>    typedef _T1 _T1_param;
>    typedef _T2 _T2_param;
>
>    typedef _T1& _T1_reference;
>    typedef _T2& _T2_reference;
>
>    typedef const _T1& _T1_const_reference;
>    typedef const _T2& _T2_const_reference;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T1_param __t1)
>        : _T1(std::__1::forward<_T1_param>(__t1)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __libcpp_compressed_pair_imp(_T2_param __t2)
>        : _T2(std::__1::forward<_T2_param>(__t2)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
>        : _T1(std::__1::forward<_T1_param>(__t1)), _T2(std::__1::forward<_T2_param>(__t2)) {}
>    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
>                                     tuple<_Args1...> __first_args,
>                                     tuple<_Args2...> __second_args,
>                                     __tuple_indices<_I1...>,
>                                     __tuple_indices<_I2...>)
>            : _T1(std::__1::forward<_Args1>(get<_I1>(__first_args))...),
>              _T2(std::__1::forward<_Args2>(get<_I2>(__second_args))...)
>            {}
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_reference first() throw() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_const_reference first() const throw() {return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_reference second() throw() {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_const_reference second() const throw() {return *this;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void swap(__libcpp_compressed_pair_imp&)
>       
>
>    {
>    }
>};
>
>template <class _T1, class _T2>
>class __compressed_pair
>    : private __libcpp_compressed_pair_imp<_T1, _T2>
>{
>    typedef __libcpp_compressed_pair_imp<_T1, _T2> base;
>public:
>    typedef typename base::_T1_param _T1_param;
>    typedef typename base::_T2_param _T2_param;
>
>    typedef typename base::_T1_reference _T1_reference;
>    typedef typename base::_T2_reference _T2_reference;
>
>    typedef typename base::_T1_const_reference _T1_const_reference;
>    typedef typename base::_T2_const_reference _T2_const_reference;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __compressed_pair() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __compressed_pair(_T1_param __t1)
>        : base(std::__1::forward<_T1_param>(__t1)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __compressed_pair(_T2_param __t2)
>        : base(std::__1::forward<_T2_param>(__t2)) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __compressed_pair(_T1_param __t1, _T2_param __t2)
>        : base(std::__1::forward<_T1_param>(__t1), std::__1::forward<_T2_param>(__t2)) {}
>    template <class... _Args1, class... _Args2>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
>                                                      tuple<_Args2...> __second_args)
>            : base(__pc, std::__1::move(__first_args), std::__1::move(__second_args),
>                   typename __make_tuple_indices<sizeof...(_Args1)>::type(),
>                   typename __make_tuple_indices<sizeof...(_Args2) >::type())
>            {}
>
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_reference first() throw() {return base::first();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T1_const_reference first() const throw() {return base::first();}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_reference second() throw() {return base::second();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _T2_const_reference second() const throw() {return base::second();}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void swap(__compressed_pair& __x)
>       
>
>        {base::swap(__x);}
>};
>
>template <class _T1, class _T2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
>       
>
>    {__x.swap(__y);}
>
>
>
>template <class _Ptr1, class _Ptr2,
>          bool = is_same<typename remove_cv<typename pointer_traits<_Ptr1>::element_type>::type,
>                         typename remove_cv<typename pointer_traits<_Ptr2>::element_type>::type
>                        >::value
>         >
>struct __same_or_less_cv_qualified_imp
>    : is_convertible<_Ptr1, _Ptr2> {};
>
>template <class _Ptr1, class _Ptr2>
>struct __same_or_less_cv_qualified_imp<_Ptr1, _Ptr2, false>
>    : false_type {};
>
>template <class _Ptr1, class _Ptr2, bool = is_pointer<_Ptr1>::value ||
>                                           is_same<_Ptr1, _Ptr2>::value ||
>                                           __has_element_type<_Ptr1>::value>
>struct __same_or_less_cv_qualified
>    : __same_or_less_cv_qualified_imp<_Ptr1, _Ptr2> {};
>
>template <class _Ptr1, class _Ptr2>
>struct __same_or_less_cv_qualified<_Ptr1, _Ptr2, false>
>    : false_type {};
>
>
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) default_delete
>{
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr default_delete() throw() = default;
>
>
>
>    template <class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__)) default_delete(const default_delete<_Up>&,
>             typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) throw() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void operator() (_Tp* __ptr) const throw()
>        {
>            static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type");
>            static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type");
>            delete __ptr;
>        }
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) default_delete<_Tp[]>
>{
>public:
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr default_delete() throw() = default;
>
>
>
>    template <class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__)) default_delete(const default_delete<_Up[]>&,
>             typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) throw() {}
>    template <class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        void operator() (_Up* __ptr,
>                         typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) const throw()
>        {
>            static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type");
>            static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type");
>            delete [] __ptr;
>        }
>};
>
>template <class _Tp, class _Dp = default_delete<_Tp> >
>class __attribute__ ((__visibility__("default"))) unique_ptr
>{
>public:
>    typedef _Tp element_type;
>    typedef _Dp deleter_type;
>    typedef typename __pointer_type<_Tp, deleter_type>::type pointer;
>private:
>    __compressed_pair<pointer, deleter_type> __ptr_;
>    struct __nat {int __for_bool_;};
>
>    typedef typename remove_reference<deleter_type>::type& _Dp_reference;
>    typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr unique_ptr() throw()
>        : __ptr_(pointer())
>        {
>            static_assert(!is_pointer<deleter_type>::value,
>                "unique_ptr constructed with null function pointer deleter");
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr unique_ptr(nullptr_t) throw()
>        : __ptr_(pointer())
>        {
>            static_assert(!is_pointer<deleter_type>::value,
>                "unique_ptr constructed with null function pointer deleter");
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit unique_ptr(pointer __p) throw()
>        : __ptr_(std::__1::move(__p))
>        {
>            static_assert(!is_pointer<deleter_type>::value,
>                "unique_ptr constructed with null function pointer deleter");
>        }
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(pointer __p, typename conditional<
>                                        is_reference<deleter_type>::value,
>                                        deleter_type,
>                                        typename add_lvalue_reference<const deleter_type>::type>::type __d)
>             throw()
>        : __ptr_(__p, __d) {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(pointer __p, typename remove_reference<deleter_type>::type&& __d)
>             throw()
>        : __ptr_(__p, std::__1::move(__d))
>        {
>            static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(unique_ptr&& __u) throw()
>        : __ptr_(__u.release(), std::__1::forward<deleter_type>(__u.get_deleter())) {}
>    template <class _Up, class _Ep>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        unique_ptr(unique_ptr<_Up, _Ep>&& __u,
>                   typename enable_if
>                      <
>                        !is_array<_Up>::value &&
>                         is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value &&
>                         is_convertible<_Ep, deleter_type>::value &&
>                         (
>                            !is_reference<deleter_type>::value ||
>                            is_same<deleter_type, _Ep>::value
>                         ),
>                         __nat
>                      >::type = __nat()) throw()
>            : __ptr_(__u.release(), std::__1::forward<_Ep>(__u.get_deleter())) {}
>
>    template <class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(auto_ptr<_Up>&& __p,
>                typename enable_if<
>                                      is_convertible<_Up*, _Tp*>::value &&
>                                      is_same<_Dp, default_delete<_Tp> >::value,
>                                      __nat
>                                  >::type = __nat()) throw()
>            : __ptr_(__p.release())
>            {
>            }
>
>        __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr& operator=(unique_ptr&& __u) throw()
>            {
>                reset(__u.release());
>                __ptr_.second() = std::__1::forward<deleter_type>(__u.get_deleter());
>                return *this;
>            }
>
>        template <class _Up, class _Ep>
>            __attribute__ ((__visibility__("hidden"), __always_inline__))
>            typename enable_if
>            <
>                !is_array<_Up>::value &&
>                is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value &&
>                is_assignable<deleter_type&, _Ep&&>::value,
>                unique_ptr&
>            >::type
>            operator=(unique_ptr<_Up, _Ep>&& __u) throw()
>            {
>                reset(__u.release());
>                __ptr_.second() = std::__1::forward<_Ep>(__u.get_deleter());
>                return *this;
>            }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ~unique_ptr() {reset();}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr& operator=(nullptr_t) throw()
>    {
>        reset();
>        return *this;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) typename add_lvalue_reference<_Tp>::type operator*() const
>        {return *__ptr_.first();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer operator->() const throw() {return __ptr_.first();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer get() const throw() {return __ptr_.first();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Dp_reference get_deleter() throw()
>        {return __ptr_.second();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Dp_const_reference get_deleter() const throw()
>        {return __ptr_.second();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        operator bool() const throw()
>        {return __ptr_.first() != nullptr;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer release() throw()
>    {
>        pointer __t = __ptr_.first();
>        __ptr_.first() = pointer();
>        return __t;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void reset(pointer __p = pointer()) throw()
>    {
>        pointer __tmp = __ptr_.first();
>        __ptr_.first() = __p;
>        if (__tmp)
>            __ptr_.second()(__tmp);
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void swap(unique_ptr& __u) throw()
>        {__ptr_.swap(__u.__ptr_);}
>};
>
>template <class _Tp, class _Dp>
>class __attribute__ ((__visibility__("default"))) unique_ptr<_Tp[], _Dp>
>{
>public:
>    typedef _Tp element_type;
>    typedef _Dp deleter_type;
>    typedef typename __pointer_type<_Tp, deleter_type>::type pointer;
>private:
>    __compressed_pair<pointer, deleter_type> __ptr_;
>    struct __nat {int __for_bool_;};
>
>    typedef typename remove_reference<deleter_type>::type& _Dp_reference;
>    typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr unique_ptr() throw()
>        : __ptr_(pointer())
>        {
>            static_assert(!is_pointer<deleter_type>::value,
>                "unique_ptr constructed with null function pointer deleter");
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr unique_ptr(nullptr_t) throw()
>        : __ptr_(pointer())
>        {
>            static_assert(!is_pointer<deleter_type>::value,
>                "unique_ptr constructed with null function pointer deleter");
>        }
>
>    template <class _Pp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit unique_ptr(_Pp __p,
>            typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value, __nat>::type = __nat()) throw()
>        : __ptr_(__p)
>        {
>            static_assert(!is_pointer<deleter_type>::value,
>                "unique_ptr constructed with null function pointer deleter");
>        }
>
>    template <class _Pp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(_Pp __p, typename conditional<
>                                       is_reference<deleter_type>::value,
>                                       deleter_type,
>                                       typename add_lvalue_reference<const deleter_type>::type>::type __d,
>                                       typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value, __nat>::type = __nat())
>             throw()
>        : __ptr_(__p, __d) {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(nullptr_t, typename conditional<
>                                       is_reference<deleter_type>::value,
>                                       deleter_type,
>                                       typename add_lvalue_reference<const deleter_type>::type>::type __d)
>             throw()
>        : __ptr_(pointer(), __d) {}
>
>    template <class _Pp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(_Pp __p,
>                                         typename remove_reference<deleter_type>::type&& __d,
>                                         typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value, __nat>::type = __nat())
>             throw()
>        : __ptr_(__p, std::__1::move(__d))
>        {
>            static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(nullptr_t, typename remove_reference<deleter_type>::type&& __d)
>             throw()
>        : __ptr_(pointer(), std::__1::move(__d))
>        {
>            static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr(unique_ptr&& __u) throw()
>        : __ptr_(__u.release(), std::__1::forward<deleter_type>(__u.get_deleter())) {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr& operator=(unique_ptr&& __u) throw()
>        {
>            reset(__u.release());
>            __ptr_.second() = std::__1::forward<deleter_type>(__u.get_deleter());
>            return *this;
>        }
>
>    template <class _Up, class _Ep>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        unique_ptr(unique_ptr<_Up, _Ep>&& __u,
>                   typename enable_if
>                            <
>                                is_array<_Up>::value &&
>                                __same_or_less_cv_qualified<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value
>                                && is_convertible<_Ep, deleter_type>::value &&
>                                (
>                                    !is_reference<deleter_type>::value ||
>                                    is_same<deleter_type, _Ep>::value
>                                ),
>                                __nat
>                            >::type = __nat()
>                  ) throw()
>        : __ptr_(__u.release(), std::__1::forward<deleter_type>(__u.get_deleter())) {}
>
>
>        template <class _Up, class _Ep>
>            __attribute__ ((__visibility__("hidden"), __always_inline__))
>            typename enable_if
>            <
>                is_array<_Up>::value &&
>                __same_or_less_cv_qualified<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value &&
>                is_assignable<deleter_type&, _Ep&&>::value,
>                unique_ptr&
>            >::type
>            operator=(unique_ptr<_Up, _Ep>&& __u) throw()
>            {
>                reset(__u.release());
>                __ptr_.second() = std::__1::forward<_Ep>(__u.get_deleter());
>                return *this;
>            }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) ~unique_ptr() {reset();}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) unique_ptr& operator=(nullptr_t) throw()
>    {
>        reset();
>        return *this;
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) typename add_lvalue_reference<_Tp>::type operator[](size_t __i) const
>        {return __ptr_.first()[__i];}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer get() const throw() {return __ptr_.first();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Dp_reference get_deleter() throw()
>        {return __ptr_.second();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) _Dp_const_reference get_deleter() const throw()
>        {return __ptr_.second();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        operator bool() const throw()
>        {return __ptr_.first() != nullptr;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) pointer release() throw()
>    {
>        pointer __t = __ptr_.first();
>        __ptr_.first() = pointer();
>        return __t;
>    }
>
>
>    template <class _Pp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value, void>::type
>    reset(_Pp __p) throw()
>    {
>        pointer __tmp = __ptr_.first();
>        __ptr_.first() = __p;
>        if (__tmp)
>            __ptr_.second()(__tmp);
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void reset(nullptr_t) throw()
>    {
>        pointer __tmp = __ptr_.first();
>        __ptr_.first() = nullptr;
>        if (__tmp)
>            __ptr_.second()(__tmp);
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void reset() throw()
>    {
>        pointer __tmp = __ptr_.first();
>        __ptr_.first() = nullptr;
>        if (__tmp)
>            __ptr_.second()(__tmp);
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void swap(unique_ptr& __u) {__ptr_.swap(__u.__ptr_);}
>private:
>};
>
>template <class _Tp, class _Dp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) throw() {__x.swap(__y);}
>
>template <class _T1, class _D1, class _T2, class _D2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();}
>
>template <class _T1, class _D1, class _T2, class _D2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);}
>
>template <class _T1, class _D1, class _T2, class _D2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
>{
>    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
>    typedef typename unique_ptr<_T2, _D2>::pointer _P2;
>    typedef typename common_type<_P1, _P2>::type _V;
>    return less<_V>()(__x.get(), __y.get());
>}
>
>template <class _T1, class _D1, class _T2, class _D2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;}
>
>template <class _T1, class _D1, class _T2, class _D2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);}
>
>template <class _T1, class _D1, class _T2, class _D2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) throw()
>{
>    return !__x;
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) throw()
>{
>    return !__x;
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) throw()
>{
>    return static_cast<bool>(__x);
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) throw()
>{
>    return static_cast<bool>(__x);
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t)
>{
>    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
>    return less<_P1>()(__x.get(), nullptr);
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x)
>{
>    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
>    return less<_P1>()(nullptr, __x.get());
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
>{
>    return nullptr < __x;
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x)
>{
>    return __x < nullptr;
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
>{
>    return !(nullptr < __x);
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
>{
>    return !(__x < nullptr);
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
>{
>    return !(__x < nullptr);
>}
>
>template <class _T1, class _D1>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
>{
>    return !(nullptr < __x);
>}
>template <class _Tp> struct hash;
>
>template <class _Size>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Size
>__loadword(const void* __p)
>{
>    _Size __r;
>    std::memcpy(&__r, __p, sizeof(__r));
>    return __r;
>}
>
>
>
>
>template <class _Size, size_t = sizeof(_Size)*8>
>struct __murmur2_or_cityhash;
>
>template <class _Size>
>struct __murmur2_or_cityhash<_Size, 32>
>{
>    _Size operator()(const void* __key, _Size __len);
>};
>
>
>template <class _Size>
>_Size
>__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len)
>{
>    const _Size __m = 0x5bd1e995;
>    const _Size __r = 24;
>    _Size __h = __len;
>    const unsigned char* __data = static_cast<const unsigned char*>(__key);
>    for (; __len >= 4; __data += 4, __len -= 4)
>    {
>        _Size __k = __loadword<_Size>(__data);
>        __k *= __m;
>        __k ^= __k >> __r;
>        __k *= __m;
>        __h *= __m;
>        __h ^= __k;
>    }
>    switch (__len)
>    {
>    case 3:
>        __h ^= __data[2] << 16;
>    case 2:
>        __h ^= __data[1] << 8;
>    case 1:
>        __h ^= __data[0];
>        __h *= __m;
>    }
>    __h ^= __h >> 13;
>    __h *= __m;
>    __h ^= __h >> 15;
>    return __h;
>}
>
>template <class _Size>
>struct __murmur2_or_cityhash<_Size, 64>
>{
>    _Size operator()(const void* __key, _Size __len);
>
> private:
>
>  static const _Size __k0 = 0xc3a5c85c97cb3127ULL;
>  static const _Size __k1 = 0xb492b66fbe98f273ULL;
>  static const _Size __k2 = 0x9ae16a3b2f90404fULL;
>  static const _Size __k3 = 0xc949d7c7509e6557ULL;
>
>  static _Size __rotate(_Size __val, int __shift) {
>    return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift)));
>  }
>
>  static _Size __rotate_by_at_least_1(_Size __val, int __shift) {
>    return (__val >> __shift) | (__val << (64 - __shift));
>  }
>
>  static _Size __shift_mix(_Size __val) {
>    return __val ^ (__val >> 47);
>  }
>
>  static _Size __hash_len_16(_Size __u, _Size __v) {
>    const _Size __mul = 0x9ddfea08eb382d69ULL;
>    _Size __a = (__u ^ __v) * __mul;
>    __a ^= (__a >> 47);
>    _Size __b = (__v ^ __a) * __mul;
>    __b ^= (__b >> 47);
>    __b *= __mul;
>    return __b;
>  }
>
>  static _Size __hash_len_0_to_16(const char* __s, _Size __len) {
>    if (__len > 8) {
>      const _Size __a = __loadword<_Size>(__s);
>      const _Size __b = __loadword<_Size>(__s + __len - 8);
>      return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b;
>    }
>    if (__len >= 4) {
>      const uint32_t __a = __loadword<uint32_t>(__s);
>      const uint32_t __b = __loadword<uint32_t>(__s + __len - 4);
>      return __hash_len_16(__len + (__a << 3), __b);
>    }
>    if (__len > 0) {
>      const unsigned char __a = __s[0];
>      const unsigned char __b = __s[__len >> 1];
>      const unsigned char __c = __s[__len - 1];
>      const uint32_t __y = static_cast<uint32_t>(__a) +
>                           (static_cast<uint32_t>(__b) << 8);
>      const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2);
>      return __shift_mix(__y * __k2 ^ __z * __k3) * __k2;
>    }
>    return __k2;
>  }
>
>  static _Size __hash_len_17_to_32(const char *__s, _Size __len) {
>    const _Size __a = __loadword<_Size>(__s) * __k1;
>    const _Size __b = __loadword<_Size>(__s + 8);
>    const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2;
>    const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0;
>    return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d,
>                         __a + __rotate(__b ^ __k3, 20) - __c + __len);
>  }
>
>
>
>  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
>      _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b) {
>    __a += __w;
>    __b = __rotate(__b + __a + __z, 21);
>    const _Size __c = __a;
>    __a += __x;
>    __a += __y;
>    __b += __rotate(__a, 44);
>    return pair<_Size, _Size>(__a + __z, __b + __c);
>  }
>
>
>  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
>      const char* __s, _Size __a, _Size __b) {
>    return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s),
>                                         __loadword<_Size>(__s + 8),
>                                         __loadword<_Size>(__s + 16),
>                                         __loadword<_Size>(__s + 24),
>                                         __a,
>                                         __b);
>  }
>
>
>  static _Size __hash_len_33_to_64(const char *__s, size_t __len) {
>    _Size __z = __loadword<_Size>(__s + 24);
>    _Size __a = __loadword<_Size>(__s) +
>                (__len + __loadword<_Size>(__s + __len - 16)) * __k0;
>    _Size __b = __rotate(__a + __z, 52);
>    _Size __c = __rotate(__a, 37);
>    __a += __loadword<_Size>(__s + 8);
>    __c += __rotate(__a, 7);
>    __a += __loadword<_Size>(__s + 16);
>    _Size __vf = __a + __z;
>    _Size __vs = __b + __rotate(__a, 31) + __c;
>    __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32);
>    __z += __loadword<_Size>(__s + __len - 8);
>    __b = __rotate(__a + __z, 52);
>    __c = __rotate(__a, 37);
>    __a += __loadword<_Size>(__s + __len - 24);
>    __c += __rotate(__a, 7);
>    __a += __loadword<_Size>(__s + __len - 16);
>    _Size __wf = __a + __z;
>    _Size __ws = __b + __rotate(__a, 31) + __c;
>    _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0);
>    return __shift_mix(__r * __k0 + __vs) * __k2;
>  }
>};
>
>
>template <class _Size>
>_Size
>__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len)
>{
>  const char* __s = static_cast<const char*>(__key);
>  if (__len <= 32) {
>    if (__len <= 16) {
>      return __hash_len_0_to_16(__s, __len);
>    } else {
>      return __hash_len_17_to_32(__s, __len);
>    }
>  } else if (__len <= 64) {
>    return __hash_len_33_to_64(__s, __len);
>  }
>
>
>
>  _Size __x = __loadword<_Size>(__s + __len - 40);
>  _Size __y = __loadword<_Size>(__s + __len - 16) +
>              __loadword<_Size>(__s + __len - 56);
>  _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len,
>                          __loadword<_Size>(__s + __len - 24));
>  pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z);
>  pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x);
>  __x = __x * __k1 + __loadword<_Size>(__s);
>
>
>  __len = (__len - 1) & ~static_cast<_Size>(63);
>  do {
>    __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1;
>    __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1;
>    __x ^= __w.second;
>    __y += __v.first + __loadword<_Size>(__s + 40);
>    __z = __rotate(__z + __w.first, 33) * __k1;
>    __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first);
>    __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second,
>                                        __y + __loadword<_Size>(__s + 16));
>    std::swap(__z, __x);
>    __s += 64;
>    __len -= 64;
>  } while (__len != 0);
>  return __hash_len_16(
>      __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z,
>      __hash_len_16(__v.second, __w.second) + __x);
>}
>
>template <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)>
>struct __scalar_hash;
>
>template <class _Tp>
>struct __scalar_hash<_Tp, 0>
>    : public unary_function<_Tp, size_t>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_t operator()(_Tp __v) const throw()
>    {
>        union
>        {
>            _Tp __t;
>            size_t __a;
>        } __u;
>        __u.__a = 0;
>        __u.__t = __v;
>        return __u.__a;
>    }
>};
>
>template <class _Tp>
>struct __scalar_hash<_Tp, 1>
>    : public unary_function<_Tp, size_t>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_t operator()(_Tp __v) const throw()
>    {
>        union
>        {
>            _Tp __t;
>            size_t __a;
>        } __u;
>        __u.__t = __v;
>        return __u.__a;
>    }
>};
>
>template <class _Tp>
>struct __scalar_hash<_Tp, 2>
>    : public unary_function<_Tp, size_t>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_t operator()(_Tp __v) const throw()
>    {
>        union
>        {
>            _Tp __t;
>            struct
>            {
>                size_t __a;
>                size_t __b;
>            };
>        } __u;
>        __u.__t = __v;
>        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
>    }
>};
>
>template <class _Tp>
>struct __scalar_hash<_Tp, 3>
>    : public unary_function<_Tp, size_t>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_t operator()(_Tp __v) const throw()
>    {
>        union
>        {
>            _Tp __t;
>            struct
>            {
>                size_t __a;
>                size_t __b;
>                size_t __c;
>            };
>        } __u;
>        __u.__t = __v;
>        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
>    }
>};
>
>template <class _Tp>
>struct __scalar_hash<_Tp, 4>
>    : public unary_function<_Tp, size_t>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_t operator()(_Tp __v) const throw()
>    {
>        union
>        {
>            _Tp __t;
>            struct
>            {
>                size_t __a;
>                size_t __b;
>                size_t __c;
>                size_t __d;
>            };
>        } __u;
>        __u.__t = __v;
>        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
>    }
>};
>
>template<class _Tp>
>struct __attribute__ ((__visibility__("default"))) hash<_Tp*>
>    : public unary_function<_Tp*, size_t>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_t operator()(_Tp* __v) const throw()
>    {
>        union
>        {
>            _Tp* __t;
>            size_t __a;
>        } __u;
>        __u.__t = __v;
>        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
>    }
>};
>
>template <class _Tp, class _Dp>
>struct __attribute__ ((__visibility__("default"))) hash<unique_ptr<_Tp, _Dp> >
>{
>    typedef unique_ptr<_Tp, _Dp> argument_type;
>    typedef size_t result_type;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    result_type operator()(const argument_type& __ptr) const throw()
>    {
>        typedef typename argument_type::pointer pointer;
>        return hash<pointer>()(__ptr.get());
>    }
>};
>
>struct __destruct_n
>{
>private:
>    size_t size;
>
>    template <class _Tp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __process(_Tp* __p, false_type) throw()
>        {for (size_t __i = 0; __i < size; ++__i, ++__p) __p->~_Tp();}
>
>    template <class _Tp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __process(_Tp*, true_type) throw()
>        {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __incr(false_type) throw()
>        {++size;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __incr(true_type) throw()
>        {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __set(size_t __s, false_type) throw()
>        {size = __s;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __set(size_t, true_type) throw()
>        {}
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __destruct_n(size_t __s) throw()
>        : size(__s) {}
>
>    template <class _Tp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __incr(_Tp*) throw()
>        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
>
>    template <class _Tp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void __set(size_t __s, _Tp*) throw()
>        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
>
>    template <class _Tp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void operator()(_Tp* __p) throw()
>        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
>};
>
>template <class _Alloc>
>class __allocator_destructor
>{
>    typedef allocator_traits<_Alloc> __alloc_traits;
>public:
>    typedef typename __alloc_traits::pointer pointer;
>    typedef typename __alloc_traits::size_type size_type;
>private:
>    _Alloc& __alloc_;
>    size_type __s_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __allocator_destructor(_Alloc& __a, size_type __s)
>             throw()
>        : __alloc_(__a), __s_(__s) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void operator()(pointer __p) throw()
>        {__alloc_traits::deallocate(__alloc_, __p, __s_);}
>};
>
>template <class _InputIterator, class _ForwardIterator>
>_ForwardIterator
>uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
>
>    _ForwardIterator __s = __r;
>    try
>    {
>
>        for (; __f != __l; ++__f, ++__r)
>            ::new(&*__r) value_type(*__f);
>
>    }
>    catch (...)
>    {
>        for (; __s != __r; ++__s)
>            __s->~value_type();
>        throw;
>    }
>
>    return __r;
>}
>
>template <class _InputIterator, class _Size, class _ForwardIterator>
>_ForwardIterator
>uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
>
>    _ForwardIterator __s = __r;
>    try
>    {
>
>        for (; __n > 0; ++__f, ++__r, --__n)
>            ::new(&*__r) value_type(*__f);
>
>    }
>    catch (...)
>    {
>        for (; __s != __r; ++__s)
>            __s->~value_type();
>        throw;
>    }
>
>    return __r;
>}
>
>template <class _ForwardIterator, class _Tp>
>void
>uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
>
>    _ForwardIterator __s = __f;
>    try
>    {
>
>        for (; __f != __l; ++__f)
>            ::new(&*__f) value_type(__x);
>
>    }
>    catch (...)
>    {
>        for (; __s != __f; ++__s)
>            __s->~value_type();
>        throw;
>    }
>
>}
>
>template <class _ForwardIterator, class _Size, class _Tp>
>_ForwardIterator
>uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
>
>    _ForwardIterator __s = __f;
>    try
>    {
>
>        for (; __n > 0; ++__f, --__n)
>            ::new(&*__f) value_type(__x);
>
>    }
>    catch (...)
>    {
>        for (; __s != __f; ++__s)
>            __s->~value_type();
>        throw;
>    }
>
>    return __f;
>}
>
>class __attribute__ ((__visibility__("default"))) bad_weak_ptr
>    : public std::exception
>{
>public:
>    virtual ~bad_weak_ptr() throw();
>    virtual const char* what() const throw();
>};
>
>template<class _Tp> class __attribute__ ((__visibility__("default"))) weak_ptr;
>
>class __attribute__ ((__visibility__("default"))) __shared_count
>{
>    __shared_count(const __shared_count&);
>    __shared_count& operator=(const __shared_count&);
>
>protected:
>    long __shared_owners_;
>    virtual ~__shared_count();
>private:
>    virtual void __on_zero_shared() throw() = 0;
>
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit __shared_count(long __refs = 0) throw()
>        : __shared_owners_(__refs) {}
>
>    void __add_shared() throw();
>    bool __release_shared() throw();
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    long use_count() const throw() {return __shared_owners_ + 1;}
>};
>
>class __attribute__ ((__visibility__("default"))) __shared_weak_count
>    : private __shared_count
>{
>    long __shared_weak_owners_;
>
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit __shared_weak_count(long __refs = 0) throw()
>        : __shared_count(__refs),
>          __shared_weak_owners_(__refs) {}
>protected:
>    virtual ~__shared_weak_count();
>
>public:
>    void __add_shared() throw();
>    void __add_weak() throw();
>    void __release_shared() throw();
>    void __release_weak() throw();
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    long use_count() const throw() {return __shared_count::use_count();}
>    __shared_weak_count* lock() throw();
>
>
>
>
>
>
>    virtual const void* __get_deleter(const type_info&) const throw();
>
>private:
>    virtual void __on_zero_shared_weak() throw() = 0;
>};
>
>template <class _Tp, class _Dp, class _Alloc>
>class __shared_ptr_pointer
>    : public __shared_weak_count
>{
>    __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
>        : __data_(__compressed_pair<_Tp, _Dp>(__p, std::__1::move(__d)), std::__1::move(__a)) {}
>
>
>    virtual const void* __get_deleter(const type_info&) const throw();
>
>
>private:
>    virtual void __on_zero_shared() throw();
>    virtual void __on_zero_shared_weak() throw();
>};
>
>
>
>template <class _Tp, class _Dp, class _Alloc>
>const void*
>__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const throw()
>{
>    return __t == typeid(_Dp) ? &__data_.first().second() : 0;
>}
>
>
>
>template <class _Tp, class _Dp, class _Alloc>
>void
>__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() throw()
>{
>    __data_.first().second()(__data_.first().first());
>    __data_.first().second().~_Dp();
>}
>
>template <class _Tp, class _Dp, class _Alloc>
>void
>__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() throw()
>{
>    typename _Alloc::template rebind<__shared_ptr_pointer>::other __a(__data_.second());
>    __data_.second().~_Alloc();
>    __a.deallocate(this, 1);
>}
>
>template <class _Tp, class _Alloc>
>class __shared_ptr_emplace
>    : public __shared_weak_count
>{
>    __compressed_pair<_Alloc, _Tp> __data_;
>public:
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __shared_ptr_emplace(_Alloc __a)
>        : __data_(std::__1::move(__a)) {}
>
>    template <class ..._Args>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
>            : __data_(piecewise_construct, std::__1::forward_as_tuple(__a),
>                   std::__1::forward_as_tuple(std::__1::forward<_Args>(__args)...)) {}
>private:
>    virtual void __on_zero_shared() throw();
>    virtual void __on_zero_shared_weak() throw();
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    _Tp* get() throw() {return &__data_.second();}
>};
>
>template <class _Tp, class _Alloc>
>void
>__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() throw()
>{
>    __data_.second().~_Tp();
>}
>
>template <class _Tp, class _Alloc>
>void
>__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() throw()
>{
>    typename _Alloc::template rebind<__shared_ptr_emplace>::other __a(__data_.first());
>    __data_.first().~_Alloc();
>    __a.deallocate(this, 1);
>}
>
>template<class _Tp> class __attribute__ ((__visibility__("default"))) enable_shared_from_this;
>
>template<class _Tp>
>class __attribute__ ((__visibility__("default"))) shared_ptr
>{
>public:
>    typedef _Tp element_type;
>private:
>    element_type* __ptr_;
>    __shared_weak_count* __cntrl_;
>
>    struct __nat {int __for_bool_;};
>public:
>    constexpr shared_ptr() throw();
>    constexpr shared_ptr(nullptr_t) throw();
>    template<class _Yp>
>        explicit shared_ptr(_Yp* __p,
>                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
>    template<class _Yp, class _Dp>
>        shared_ptr(_Yp* __p, _Dp __d,
>                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
>    template<class _Yp, class _Dp, class _Alloc>
>        shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
>                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
>    template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
>    template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
>    template<class _Yp> shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) throw();
>    shared_ptr(const shared_ptr& __r) throw();
>    template<class _Yp>
>        shared_ptr(const shared_ptr<_Yp>& __r,
>                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat())
>                       throw();
>
>    shared_ptr(shared_ptr&& __r) throw();
>    template<class _Yp> shared_ptr(shared_ptr<_Yp>&& __r,
>                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat())
>                       throw();
>
>    template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
>                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type= __nat());
>
>    template<class _Yp>
>        shared_ptr(auto_ptr<_Yp>&& __r,
>                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
>
>
>
>
>
>
>    template <class _Yp, class _Dp>
>        shared_ptr(unique_ptr<_Yp, _Dp>&&,
>                   typename enable_if
>                   <
>                       !is_lvalue_reference<_Dp>::value &&
>                       !is_array<_Yp>::value &&
>                       is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
>                       __nat
>                   >::type = __nat());
>    template <class _Yp, class _Dp>
>        shared_ptr(unique_ptr<_Yp, _Dp>&&,
>                   typename enable_if
>                   <
>                       is_lvalue_reference<_Dp>::value &&
>                       !is_array<_Yp>::value &&
>                       is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
>                       __nat
>                   >::type = __nat());
>    ~shared_ptr();
>
>    shared_ptr& operator=(const shared_ptr& __r) throw();
>    template<class _Yp>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            shared_ptr&
>        >::type
>        operator=(const shared_ptr<_Yp>& __r) throw();
>
>    shared_ptr& operator=(shared_ptr&& __r) throw();
>    template<class _Yp>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            shared_ptr<_Tp>&
>        >::type
>        operator=(shared_ptr<_Yp>&& __r);
>    template<class _Yp>
>        typename enable_if
>        <
>            !is_array<_Yp>::value &&
>            is_convertible<_Yp*, element_type*>::value,
>            shared_ptr
>        >::type&
>        operator=(auto_ptr<_Yp>&& __r);
>    template <class _Yp, class _Dp>
>        typename enable_if
>        <
>            !is_array<_Yp>::value &&
>            is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
>            shared_ptr&
>        >::type
>
>        operator=(unique_ptr<_Yp, _Dp>&& __r);
>
>
>
>
>    void swap(shared_ptr& __r) throw();
>    void reset() throw();
>    template<class _Yp>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            void
>        >::type
>        reset(_Yp* __p);
>    template<class _Yp, class _Dp>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            void
>        >::type
>        reset(_Yp* __p, _Dp __d);
>    template<class _Yp, class _Dp, class _Alloc>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            void
>        >::type
>        reset(_Yp* __p, _Dp __d, _Alloc __a);
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    element_type* get() const throw() {return __ptr_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    typename add_lvalue_reference<element_type>::type operator*() const throw()
>        {return *__ptr_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    element_type* operator->() const throw() {return __ptr_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    long use_count() const throw() {return __cntrl_ ? __cntrl_->use_count() : 0;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool unique() const throw() {return use_count() == 1;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    operator bool() const throw() {return get() != 0;}
>    template <class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        bool owner_before(shared_ptr<_Up> const& __p) const
>        {return __cntrl_ < __p.__cntrl_;}
>    template <class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        bool owner_before(weak_ptr<_Up> const& __p) const
>        {return __cntrl_ < __p.__cntrl_;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool
>    __owner_equivalent(const shared_ptr& __p) const
>        {return __cntrl_ == __p.__cntrl_;}
>
>
>    template <class _Dp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        _Dp* __get_deleter() const throw()
>            {return (_Dp*)(__cntrl_ ? __cntrl_->__get_deleter(typeid(_Dp)) : 0);}
>
>
>
>
>    template<class ..._Args>
>        static
>        shared_ptr<_Tp>
>        make_shared(_Args&& ...__args);
>
>    template<class _Alloc, class ..._Args>
>        static
>        shared_ptr<_Tp>
>        allocate_shared(const _Alloc& __a, _Args&& ...__args);
>private:
>
>    template <class _Yp>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        void
>        __enable_weak_this(const enable_shared_from_this<_Yp>* __e) throw()
>        {
>            if (__e)
>                __e->__weak_this_ = *this;
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void __enable_weak_this(const void*) throw() {}
>
>    template <class _Up> friend class __attribute__ ((__visibility__("default"))) shared_ptr;
>    template <class _Up> friend class __attribute__ ((__visibility__("default"))) weak_ptr;
>};
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>constexpr
>shared_ptr<_Tp>::shared_ptr() throw()
>    : __ptr_(0),
>      __cntrl_(0)
>{
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>constexpr
>shared_ptr<_Tp>::shared_ptr(nullptr_t) throw()
>    : __ptr_(0),
>      __cntrl_(0)
>{
>}
>
>template<class _Tp>
>template<class _Yp>
>shared_ptr<_Tp>::shared_ptr(_Yp* __p,
>                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
>    : __ptr_(__p)
>{
>    unique_ptr<_Yp> __hold(__p);
>    typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
>    __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), allocator<_Yp>());
>    __hold.release();
>    __enable_weak_this(__p);
>}
>
>template<class _Tp>
>template<class _Yp, class _Dp>
>shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
>                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
>    : __ptr_(__p)
>{
>
>    try
>    {
>
>        typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk;
>        __cntrl_ = new _CntrlBlk(__p, __d, allocator<_Yp>());
>        __enable_weak_this(__p);
>
>    }
>    catch (...)
>    {
>        __d(__p);
>        throw;
>    }
>
>}
>
>template<class _Tp>
>template<class _Dp>
>shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)
>    : __ptr_(0)
>{
>
>    try
>    {
>
>        typedef __shared_ptr_pointer<nullptr_t, _Dp, allocator<_Tp> > _CntrlBlk;
>        __cntrl_ = new _CntrlBlk(__p, __d, allocator<_Tp>());
>
>    }
>    catch (...)
>    {
>        __d(__p);
>        throw;
>    }
>
>}
>
>template<class _Tp>
>template<class _Yp, class _Dp, class _Alloc>
>shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
>                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
>    : __ptr_(__p)
>{
>
>    try
>    {
>
>        typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
>        typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2;
>        typedef __allocator_destructor<_A2> _D2;
>        _A2 __a2(__a);
>        unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
>        ::new(__hold2.get()) _CntrlBlk(__p, __d, __a);
>        __cntrl_ = __hold2.release();
>        __enable_weak_this(__p);
>
>    }
>    catch (...)
>    {
>        __d(__p);
>        throw;
>    }
>
>}
>
>template<class _Tp>
>template<class _Dp, class _Alloc>
>shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a)
>    : __ptr_(0)
>{
>
>    try
>    {
>
>        typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
>        typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2;
>        typedef __allocator_destructor<_A2> _D2;
>        _A2 __a2(__a);
>        unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
>        ::new(__hold2.get()) _CntrlBlk(__p, __d, __a);
>        __cntrl_ = __hold2.release();
>
>    }
>    catch (...)
>    {
>        __d(__p);
>        throw;
>    }
>
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) throw()
>    : __ptr_(__p),
>      __cntrl_(__r.__cntrl_)
>{
>    if (__cntrl_)
>        __cntrl_->__add_shared();
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    if (__cntrl_)
>        __cntrl_->__add_shared();
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
>                            typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type)
>         throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    if (__cntrl_)
>        __cntrl_->__add_shared();
>}
>
>
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    __r.__ptr_ = 0;
>    __r.__cntrl_ = 0;
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
>                            typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type)
>         throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    __r.__ptr_ = 0;
>    __r.__cntrl_ = 0;
>}
>
>
>
>template<class _Tp>
>template<class _Yp>
>
>shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r,
>
>
>
>                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
>    : __ptr_(__r.get())
>{
>    typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
>    __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
>    __enable_weak_this(__r.get());
>    __r.release();
>}
>
>template<class _Tp>
>template <class _Yp, class _Dp>
>
>shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
>
>
>
>                            typename enable_if
>                            <
>                                !is_lvalue_reference<_Dp>::value &&
>                                !is_array<_Yp>::value &&
>                                is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
>                                __nat
>                            >::type)
>    : __ptr_(__r.get())
>{
>    typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk;
>    __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), allocator<_Yp>());
>    __enable_weak_this(__r.get());
>    __r.release();
>}
>
>template<class _Tp>
>template <class _Yp, class _Dp>
>
>shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
>
>
>
>                            typename enable_if
>                            <
>                                is_lvalue_reference<_Dp>::value &&
>                                !is_array<_Yp>::value &&
>                                is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
>                                __nat
>                            >::type)
>    : __ptr_(__r.get())
>{
>    typedef __shared_ptr_pointer<_Yp*,
>                                 reference_wrapper<typename remove_reference<_Dp>::type>,
>                                 allocator<_Yp> > _CntrlBlk;
>    __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), allocator<_Yp>());
>    __enable_weak_this(__r.get());
>    __r.release();
>}
>
>
>
>template<class _Tp>
>template<class ..._Args>
>shared_ptr<_Tp>
>shared_ptr<_Tp>::make_shared(_Args&& ...__args)
>{
>    typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
>    typedef allocator<_CntrlBlk> _A2;
>    typedef __allocator_destructor<_A2> _D2;
>    _A2 __a2;
>    unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
>    ::new(__hold2.get()) _CntrlBlk(__a2, std::__1::forward<_Args>(__args)...);
>    shared_ptr<_Tp> __r;
>    __r.__ptr_ = __hold2.get()->get();
>    __r.__cntrl_ = __hold2.release();
>    __r.__enable_weak_this(__r.__ptr_);
>    return __r;
>}
>
>template<class _Tp>
>template<class _Alloc, class ..._Args>
>shared_ptr<_Tp>
>shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
>{
>    typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
>    typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2;
>    typedef __allocator_destructor<_A2> _D2;
>    _A2 __a2(__a);
>    unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
>    ::new(__hold2.get()) _CntrlBlk(__a, std::__1::forward<_Args>(__args)...);
>    shared_ptr<_Tp> __r;
>    __r.__ptr_ = __hold2.get()->get();
>    __r.__cntrl_ = __hold2.release();
>    __r.__enable_weak_this(__r.__ptr_);
>    return __r;
>}
>template<class _Tp>
>shared_ptr<_Tp>::~shared_ptr()
>{
>    if (__cntrl_)
>        __cntrl_->__release_shared();
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>shared_ptr<_Tp>&
>shared_ptr<_Tp>::operator=(const shared_ptr& __r) throw()
>{
>    shared_ptr(__r).swap(*this);
>    return *this;
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    shared_ptr<_Tp>&
>>::type
>shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) throw()
>{
>    shared_ptr(__r).swap(*this);
>    return *this;
>}
>
>
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>shared_ptr<_Tp>&
>shared_ptr<_Tp>::operator=(shared_ptr&& __r) throw()
>{
>    shared_ptr(std::__1::move(__r)).swap(*this);
>    return *this;
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    shared_ptr<_Tp>&
>>::type
>shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
>{
>    shared_ptr(std::__1::move(__r)).swap(*this);
>    return *this;
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    !is_array<_Yp>::value &&
>    is_convertible<_Yp*, _Tp*>::value,
>    shared_ptr<_Tp>
>>::type&
>shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
>{
>    shared_ptr(std::__1::move(__r)).swap(*this);
>    return *this;
>}
>
>template<class _Tp>
>template <class _Yp, class _Dp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    !is_array<_Yp>::value &&
>    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, _Tp*>::value,
>    shared_ptr<_Tp>&
>>::type
>shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
>{
>    shared_ptr(std::__1::move(__r)).swap(*this);
>    return *this;
>}
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>shared_ptr<_Tp>::swap(shared_ptr& __r) throw()
>{
>    std::__1::swap(__ptr_, __r.__ptr_);
>    std::__1::swap(__cntrl_, __r.__cntrl_);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>shared_ptr<_Tp>::reset() throw()
>{
>    shared_ptr().swap(*this);
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    void
>>::type
>shared_ptr<_Tp>::reset(_Yp* __p)
>{
>    shared_ptr(__p).swap(*this);
>}
>
>template<class _Tp>
>template<class _Yp, class _Dp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    void
>>::type
>shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
>{
>    shared_ptr(__p, __d).swap(*this);
>}
>
>template<class _Tp>
>template<class _Yp, class _Dp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    void
>>::type
>shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
>{
>    shared_ptr(__p, __d, __a).swap(*this);
>}
>
>
>
>template<class _Tp, class ..._Args>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    !is_array<_Tp>::value,
>    shared_ptr<_Tp>
>>::type
>make_shared(_Args&& ...__args)
>{
>    return shared_ptr<_Tp>::make_shared(std::__1::forward<_Args>(__args)...);
>}
>
>template<class _Tp, class _Alloc, class ..._Args>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    !is_array<_Tp>::value,
>    shared_ptr<_Tp>
>>::type
>allocate_shared(const _Alloc& __a, _Args&& ...__args)
>{
>    return shared_ptr<_Tp>::allocate_shared(__a, std::__1::forward<_Args>(__args)...);
>}
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) throw()
>{
>    return __x.get() == __y.get();
>}
>
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) throw()
>{
>    return !(__x == __y);
>}
>
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) throw()
>{
>    typedef typename common_type<_Tp*, _Up*>::type _V;
>    return less<_V>()(__x.get(), __y.get());
>}
>
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) throw()
>{
>    return __y < __x;
>}
>
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) throw()
>{
>    return !(__y < __x);
>}
>
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) throw()
>{
>    return !(__x < __y);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(const shared_ptr<_Tp>& __x, nullptr_t) throw()
>{
>    return !__x;
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator==(nullptr_t, const shared_ptr<_Tp>& __x) throw()
>{
>    return !__x;
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(const shared_ptr<_Tp>& __x, nullptr_t) throw()
>{
>    return static_cast<bool>(__x);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator!=(nullptr_t, const shared_ptr<_Tp>& __x) throw()
>{
>    return static_cast<bool>(__x);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(const shared_ptr<_Tp>& __x, nullptr_t) throw()
>{
>    return less<_Tp*>()(__x.get(), nullptr);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<(nullptr_t, const shared_ptr<_Tp>& __x) throw()
>{
>    return less<_Tp*>()(nullptr, __x.get());
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(const shared_ptr<_Tp>& __x, nullptr_t) throw()
>{
>    return nullptr < __x;
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>(nullptr_t, const shared_ptr<_Tp>& __x) throw()
>{
>    return __x < nullptr;
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(const shared_ptr<_Tp>& __x, nullptr_t) throw()
>{
>    return !(nullptr < __x);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator<=(nullptr_t, const shared_ptr<_Tp>& __x) throw()
>{
>    return !(__x < nullptr);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(const shared_ptr<_Tp>& __x, nullptr_t) throw()
>{
>    return !(__x < nullptr);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>operator>=(nullptr_t, const shared_ptr<_Tp>& __x) throw()
>{
>    return !(nullptr < __x);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) throw()
>{
>    __x.swap(__y);
>}
>
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    !is_array<_Tp>::value && !is_array<_Up>::value,
>    shared_ptr<_Tp>
>>::type
>static_pointer_cast(const shared_ptr<_Up>& __r) throw()
>{
>    return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get()));
>}
>
>template<class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    !is_array<_Tp>::value && !is_array<_Up>::value,
>    shared_ptr<_Tp>
>>::type
>dynamic_pointer_cast(const shared_ptr<_Up>& __r) throw()
>{
>    _Tp* __p = dynamic_cast<_Tp*>(__r.get());
>    return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
>}
>
>template<class _Tp, class _Up>
>typename enable_if
><
>    is_array<_Tp>::value == is_array<_Up>::value,
>    shared_ptr<_Tp>
>>::type
>const_pointer_cast(const shared_ptr<_Up>& __r) throw()
>{
>    typedef typename remove_extent<_Tp>::type _RTp;
>    return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
>}
>
>
>
>template<class _Dp, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Dp*
>get_deleter(const shared_ptr<_Tp>& __p) throw()
>{
>    return __p.template __get_deleter<_Dp>();
>}
>
>
>
>template<class _Tp>
>class __attribute__ ((__visibility__("default"))) weak_ptr
>{
>public:
>    typedef _Tp element_type;
>private:
>    element_type* __ptr_;
>    __shared_weak_count* __cntrl_;
>
>public:
>    constexpr weak_ptr() throw();
>    template<class _Yp> weak_ptr(shared_ptr<_Yp> const& __r,
>                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
>                        throw();
>    weak_ptr(weak_ptr const& __r) throw();
>    template<class _Yp> weak_ptr(weak_ptr<_Yp> const& __r,
>                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
>                         throw();
>
>
>    weak_ptr(weak_ptr&& __r) throw();
>    template<class _Yp> weak_ptr(weak_ptr<_Yp>&& __r,
>                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
>                         throw();
>
>    ~weak_ptr();
>
>    weak_ptr& operator=(weak_ptr const& __r) throw();
>    template<class _Yp>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            weak_ptr&
>        >::type
>        operator=(weak_ptr<_Yp> const& __r) throw();
>
>
>
>    weak_ptr& operator=(weak_ptr&& __r) throw();
>    template<class _Yp>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            weak_ptr&
>        >::type
>        operator=(weak_ptr<_Yp>&& __r) throw();
>
>
>
>    template<class _Yp>
>        typename enable_if
>        <
>            is_convertible<_Yp*, element_type*>::value,
>            weak_ptr&
>        >::type
>        operator=(shared_ptr<_Yp> const& __r) throw();
>
>    void swap(weak_ptr& __r) throw();
>    void reset() throw();
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    long use_count() const throw()
>        {return __cntrl_ ? __cntrl_->use_count() : 0;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool expired() const throw()
>        {return __cntrl_ == 0 || __cntrl_->use_count() == 0;}
>    shared_ptr<_Tp> lock() const throw();
>    template<class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        bool owner_before(const shared_ptr<_Up>& __r) const
>        {return __cntrl_ < __r.__cntrl_;}
>    template<class _Up>
>        __attribute__ ((__visibility__("hidden"), __always_inline__))
>        bool owner_before(const weak_ptr<_Up>& __r) const
>        {return __cntrl_ < __r.__cntrl_;}
>
>    template <class _Up> friend class __attribute__ ((__visibility__("default"))) weak_ptr;
>    template <class _Up> friend class __attribute__ ((__visibility__("default"))) shared_ptr;
>};
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>constexpr
>weak_ptr<_Tp>::weak_ptr() throw()
>    : __ptr_(0),
>      __cntrl_(0)
>{
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    if (__cntrl_)
>        __cntrl_->__add_weak();
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
>                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
>                         throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    if (__cntrl_)
>        __cntrl_->__add_weak();
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
>                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
>         throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    if (__cntrl_)
>        __cntrl_->__add_weak();
>}
>
>
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    __r.__ptr_ = 0;
>    __r.__cntrl_ = 0;
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
>                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
>         throw()
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_)
>{
>    __r.__ptr_ = 0;
>    __r.__cntrl_ = 0;
>}
>
>
>
>template<class _Tp>
>weak_ptr<_Tp>::~weak_ptr()
>{
>    if (__cntrl_)
>        __cntrl_->__release_weak();
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>weak_ptr<_Tp>&
>weak_ptr<_Tp>::operator=(weak_ptr const& __r) throw()
>{
>    weak_ptr(__r).swap(*this);
>    return *this;
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    weak_ptr<_Tp>&
>>::type
>weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) throw()
>{
>    weak_ptr(__r).swap(*this);
>    return *this;
>}
>
>
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>weak_ptr<_Tp>&
>weak_ptr<_Tp>::operator=(weak_ptr&& __r) throw()
>{
>    weak_ptr(std::__1::move(__r)).swap(*this);
>    return *this;
>}
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    weak_ptr<_Tp>&
>>::type
>weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) throw()
>{
>    weak_ptr(std::__1::move(__r)).swap(*this);
>    return *this;
>}
>
>
>
>template<class _Tp>
>template<class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_convertible<_Yp*, _Tp*>::value,
>    weak_ptr<_Tp>&
>>::type
>weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) throw()
>{
>    weak_ptr(__r).swap(*this);
>    return *this;
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>weak_ptr<_Tp>::swap(weak_ptr& __r) throw()
>{
>    std::__1::swap(__ptr_, __r.__ptr_);
>    std::__1::swap(__cntrl_, __r.__cntrl_);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) throw()
>{
>    __x.swap(__y);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>weak_ptr<_Tp>::reset() throw()
>{
>    weak_ptr().swap(*this);
>}
>
>template<class _Tp>
>template<class _Yp>
>shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r,
>                            typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type)
>    : __ptr_(__r.__ptr_),
>      __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
>{
>    if (__cntrl_ == 0)
>
>        throw bad_weak_ptr();
>
>
>
>}
>
>template<class _Tp>
>shared_ptr<_Tp>
>weak_ptr<_Tp>::lock() const throw()
>{
>    shared_ptr<_Tp> __r;
>    __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
>    if (__r.__cntrl_)
>        __r.__ptr_ = __ptr_;
>    return __r;
>}
>
>template <class _Tp> struct owner_less;
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) owner_less<shared_ptr<_Tp> >
>    : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
>{
>    typedef bool result_type;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const
>        {return __x.owner_before(__y);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const
>        {return __x.owner_before(__y);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const
>        {return __x.owner_before(__y);}
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) owner_less<weak_ptr<_Tp> >
>    : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
>{
>    typedef bool result_type;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const
>        {return __x.owner_before(__y);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const
>        {return __x.owner_before(__y);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const
>        {return __x.owner_before(__y);}
>};
>
>template<class _Tp>
>class __attribute__ ((__visibility__("default"))) enable_shared_from_this
>{
>    mutable weak_ptr<_Tp> __weak_this_;
>protected:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) constexpr
>    enable_shared_from_this() throw() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    enable_shared_from_this(enable_shared_from_this const&) throw() {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    enable_shared_from_this& operator=(enable_shared_from_this const&) throw()
>        {return *this;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    ~enable_shared_from_this() {}
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    shared_ptr<_Tp> shared_from_this()
>        {return shared_ptr<_Tp>(__weak_this_);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    shared_ptr<_Tp const> shared_from_this() const
>        {return shared_ptr<const _Tp>(__weak_this_);}
>
>    template <class _Up> friend class shared_ptr;
>};
>
>template <class _Tp>
>struct __attribute__ ((__visibility__("default"))) hash<shared_ptr<_Tp> >
>{
>    typedef shared_ptr<_Tp> argument_type;
>    typedef size_t result_type;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    result_type operator()(const argument_type& __ptr) const throw()
>    {
>        return hash<_Tp*>()(__ptr.get());
>    }
>};
>
>template<class _CharT, class _Traits, class _Yp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>basic_ostream<_CharT, _Traits>&
>operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
>struct __attribute__ ((__visibility__("default"))) pointer_safety
>{
>    enum __lx
>    {
>        relaxed,
>        preferred,
>        strict
>    };
>
>    __lx __v_;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pointer_safety(__lx __v) : __v_(__v) {}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    operator int() const {return __v_;}
>};
>
>__attribute__ ((__visibility__("default"))) void declare_reachable(void* __p);
>__attribute__ ((__visibility__("default"))) void declare_no_pointers(char* __p, size_t __n);
>__attribute__ ((__visibility__("default"))) void undeclare_no_pointers(char* __p, size_t __n);
>__attribute__ ((__visibility__("default"))) pointer_safety get_pointer_safety() throw();
>__attribute__ ((__visibility__("default"))) void* __undeclare_reachable(void* __p);
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp*
>undeclare_reachable(_Tp* __p)
>{
>    return static_cast<_Tp*>(__undeclare_reachable(__p));
>}
>
>__attribute__ ((__visibility__("default"))) void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
>
>} }
>
>
>
>
>
>       
>
>
>namespace std { namespace __1 {
>
>
>
>
>template <class _T1, class _T2 = _T1>
>struct __equal_to
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;}
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;}
>};
>
>template <class _T1>
>struct __equal_to<_T1, _T1>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
>};
>
>template <class _T1>
>struct __equal_to<const _T1, _T1>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
>};
>
>template <class _T1>
>struct __equal_to<_T1, const _T1>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
>};
>
>template <class _T1, class _T2 = _T1>
>struct __less
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
>};
>
>template <class _T1>
>struct __less<_T1, _T1>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
>};
>
>template <class _T1>
>struct __less<const _T1, _T1>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
>};
>
>template <class _T1>
>struct __less<_T1, const _T1>
>{
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
>};
>
>template <class _Predicate>
>class __negate
>{
>private:
>    _Predicate __p_;
>public:
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) __negate() {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit __negate(_Predicate __p) : __p_(__p) {}
>
>    template <class _T1>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x) {return !__p_(__x);}
>
>    template <class _T1, class _T2>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);}
>};
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>unsigned
>__ctz(unsigned __x)
>{
>    return static_cast<unsigned>(__builtin_ctz(__x));
>}
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>unsigned long
>__ctz(unsigned long __x)
>{
>    return static_cast<unsigned long>(__builtin_ctzl(__x));
>}
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>unsigned long long
>__ctz(unsigned long long __x)
>{
>    return static_cast<unsigned long long>(__builtin_ctzll(__x));
>}
>
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>unsigned
>__clz(unsigned __x)
>{
>    return static_cast<unsigned>(__builtin_clz(__x));
>}
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>unsigned long
>__clz(unsigned long __x)
>{
>    return static_cast<unsigned long>(__builtin_clzl (__x));
>}
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>unsigned long long
>__clz(unsigned long long __x)
>{
>    return static_cast<unsigned long long>(__builtin_clzll(__x));
>}
>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) int __pop_count(unsigned __x) {return __builtin_popcount (__x);}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) int __pop_count(unsigned long __x) {return __builtin_popcountl (__x);}
>inline __attribute__ ((__visibility__("hidden"), __always_inline__)) int __pop_count(unsigned long long __x) {return __builtin_popcountll(__x);}
>
>
>
>template <class _InputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>        if (!__pred(*__first))
>            return false;
>    return true;
>}
>
>
>
>template <class _InputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>        if (__pred(*__first))
>            return true;
>    return false;
>}
>
>
>
>template <class _InputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>        if (__pred(*__first))
>            return false;
>    return true;
>}
>
>
>
>template <class _InputIterator, class _Function>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Function
>for_each(_InputIterator __first, _InputIterator __last, _Function __f)
>{
>    for (; __first != __last; ++__first)
>        __f(*__first);
>    return std::__1::move(__f);
>}
>
>
>
>template <class _InputIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_InputIterator
>find(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
>{
>    for (; __first != __last; ++__first)
>        if (*__first == __value_)
>            break;
>    return __first;
>}
>
>
>
>template <class _InputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_InputIterator
>find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>        if (__pred(*__first))
>            break;
>    return __first;
>}
>
>
>
>template<class _InputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_InputIterator
>find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>        if (!__pred(*__first))
>            break;
>    return __first;
>}
>
>
>
>template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
>_ForwardIterator1
>__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>           _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
>           forward_iterator_tag, forward_iterator_tag)
>{
>
>    _ForwardIterator1 __r = __last1;
>    if (__first2 == __last2)
>        return __r;
>    while (true)
>    {
>        while (true)
>        {
>            if (__first1 == __last1)
>                return __r;
>            if (__pred(*__first1, *__first2))
>                break;
>            ++__first1;
>        }
>
>        _ForwardIterator1 __m1 = __first1;
>        _ForwardIterator2 __m2 = __first2;
>        while (true)
>        {
>            if (++__m2 == __last2)
>            {
>                __r = __first1;
>                ++__first1;
>                break;
>            }
>            if (++__m1 == __last1)
>                return __r;
>            if (!__pred(*__m1, *__m2))
>            {
>                ++__first1;
>                break;
>            }
>        }
>    }
>}
>
>template <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2>
>_BidirectionalIterator1
>__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
>           _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred,
>           bidirectional_iterator_tag, bidirectional_iterator_tag)
>{
>
>    if (__first2 == __last2)
>        return __last1;
>    _BidirectionalIterator1 __l1 = __last1;
>    _BidirectionalIterator2 __l2 = __last2;
>    --__l2;
>    while (true)
>    {
>
>        while (true)
>        {
>            if (__first1 == __l1)
>                return __last1;
>            if (__pred(*--__l1, *__l2))
>                break;
>        }
>
>        _BidirectionalIterator1 __m1 = __l1;
>        _BidirectionalIterator2 __m2 = __l2;
>        while (true)
>        {
>            if (__m2 == __first2)
>                return __m1;
>            if (__m1 == __first1)
>                return __last1;
>            if (!__pred(*--__m1, *--__m2))
>            {
>                break;
>            }
>        }
>    }
>}
>
>template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
>_RandomAccessIterator1
>__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
>           _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
>           random_access_iterator_tag, random_access_iterator_tag)
>{
>
>    typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2;
>    if (__len2 == 0)
>        return __last1;
>    typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1;
>    if (__len1 < __len2)
>        return __last1;
>    const _RandomAccessIterator1 __s = __first1 + (__len2 - 1);
>    _RandomAccessIterator1 __l1 = __last1;
>    _RandomAccessIterator2 __l2 = __last2;
>    --__l2;
>    while (true)
>    {
>        while (true)
>        {
>            if (__s == __l1)
>                return __last1;
>            if (__pred(*--__l1, *__l2))
>                break;
>        }
>        _RandomAccessIterator1 __m1 = __l1;
>        _RandomAccessIterator2 __m2 = __l2;
>        while (true)
>        {
>            if (__m2 == __first2)
>                return __m1;
>
>            if (!__pred(*--__m1, *--__m2))
>            {
>                break;
>            }
>        }
>    }
>}
>
>template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator1
>find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
>{
>    return std::__1::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type>
>                         (__first1, __last1, __first2, __last2, __pred,
>                          typename iterator_traits<_ForwardIterator1>::iterator_category(),
>                          typename iterator_traits<_ForwardIterator2>::iterator_category());
>}
>
>template <class _ForwardIterator1, class _ForwardIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator1
>find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>         _ForwardIterator2 __first2, _ForwardIterator2 __last2)
>{
>    typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
>    typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
>    return std::__1::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
>}
>
>
>
>template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
>_ForwardIterator1
>find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>              _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
>{
>    for (; __first1 != __last1; ++__first1)
>        for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
>            if (__pred(*__first1, *__j))
>                return __first1;
>    return __last1;
>}
>
>template <class _ForwardIterator1, class _ForwardIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator1
>find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>              _ForwardIterator2 __first2, _ForwardIterator2 __last2)
>{
>    typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
>    typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
>    return std::__1::find_first_of(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
>}
>
>
>
>template <class _ForwardIterator, class _BinaryPredicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
>{
>    if (__first != __last)
>    {
>        _ForwardIterator __i = __first;
>        while (++__i != __last)
>        {
>            if (__pred(*__first, *__i))
>                return __first;
>            __first = __i;
>        }
>    }
>    return __last;
>}
>
>template <class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type __v;
>    return std::__1::adjacent_find(__first, __last, __equal_to<__v>());
>}
>
>
>
>template <class _InputIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename iterator_traits<_InputIterator>::difference_type
>count(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
>{
>    typename iterator_traits<_InputIterator>::difference_type __r(0);
>    for (; __first != __last; ++__first)
>        if (*__first == __value_)
>            ++__r;
>    return __r;
>}
>
>
>
>template <class _InputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename iterator_traits<_InputIterator>::difference_type
>count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>{
>    typename iterator_traits<_InputIterator>::difference_type __r(0);
>    for (; __first != __last; ++__first)
>        if (__pred(*__first))
>            ++__r;
>    return __r;
>}
>
>
>
>template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<_InputIterator1, _InputIterator2>
>mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
>         _InputIterator2 __first2, _BinaryPredicate __pred)
>{
>    for (; __first1 != __last1; ++__first1, ++__first2)
>        if (!__pred(*__first1, *__first2))
>            break;
>    return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
>}
>
>template <class _InputIterator1, class _InputIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<_InputIterator1, _InputIterator2>
>mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
>{
>    typedef typename iterator_traits<_InputIterator1>::value_type __v1;
>    typedef typename iterator_traits<_InputIterator2>::value_type __v2;
>    return std::__1::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
>}
>template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred)
>{
>    for (; __first1 != __last1; ++__first1, ++__first2)
>        if (!__pred(*__first1, *__first2))
>            return false;
>    return true;
>}
>
>template <class _InputIterator1, class _InputIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
>{
>    typedef typename iterator_traits<_InputIterator1>::value_type __v1;
>    typedef typename iterator_traits<_InputIterator2>::value_type __v2;
>    return std::__1::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
>}
>template<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
>bool
>is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>               _ForwardIterator2 __first2, _BinaryPredicate __pred)
>{
>
>    for (; __first1 != __last1; ++__first1, ++__first2)
>        if (!__pred(*__first1, *__first2))
>            goto __not_done;
>    return true;
>__not_done:
>
>    typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
>    _D1 __l1 = std::__1::distance(__first1, __last1);
>    if (__l1 == _D1(1))
>        return false;
>    _ForwardIterator2 __last2 = std::__1::next(__first2, __l1);
>
>
>    for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
>    {
>
>        for (_ForwardIterator1 __j = __first1; __j != __i; ++__j)
>            if (__pred(*__j, *__i))
>                goto __next_iter;
>        {
>
>            _D1 __c2 = 0;
>            for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
>                if (__pred(*__i, *__j))
>                    ++__c2;
>            if (__c2 == 0)
>                return false;
>
>            _D1 __c1 = 1;
>            for (_ForwardIterator1 __j = std::__1::next(__i); __j != __last1; ++__j)
>                if (__pred(*__i, *__j))
>                    ++__c1;
>            if (__c1 != __c2)
>                return false;
>        }
>__next_iter:;
>    }
>    return true;
>}
>
>template<class _ForwardIterator1, class _ForwardIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>               _ForwardIterator2 __first2)
>{
>    typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
>    typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
>    return std::__1::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
>}
>template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
>_ForwardIterator1
>__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
>         forward_iterator_tag, forward_iterator_tag)
>{
>    if (__first2 == __last2)
>        return __first1;
>    while (true)
>    {
>
>        while (true)
>        {
>            if (__first1 == __last1)
>                return __last1;
>            if (__pred(*__first1, *__first2))
>                break;
>            ++__first1;
>        }
>
>        _ForwardIterator1 __m1 = __first1;
>        _ForwardIterator2 __m2 = __first2;
>        while (true)
>        {
>            if (++__m2 == __last2)
>                return __first1;
>            if (++__m1 == __last1)
>                return __last1;
>            if (!__pred(*__m1, *__m2))
>            {
>                ++__first1;
>                break;
>            }
>        }
>    }
>}
>
>template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
>_RandomAccessIterator1
>__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
>           _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
>           random_access_iterator_tag, random_access_iterator_tag)
>{
>    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _D1;
>    typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _D2;
>
>    _D2 __len2 = __last2 - __first2;
>    if (__len2 == 0)
>        return __first1;
>    _D1 __len1 = __last1 - __first1;
>    if (__len1 < __len2)
>        return __last1;
>    const _RandomAccessIterator1 __s = __last1 - (__len2 - 1);
>    while (true)
>    {
>
>        while (true)
>        {
>            if (__first1 == __s)
>                return __last1;
>            if (__pred(*__first1, *__first2))
>                break;
>            ++__first1;
>        }
>        _RandomAccessIterator1 __m1 = __first1;
>        _RandomAccessIterator2 __m2 = __first2;
>
>         while (true)
>         {
>             if (++__m2 == __last2)
>                 return __first1;
>             ++__m1;
>             if (!__pred(*__m1, *__m2))
>             {
>                 ++__first1;
>                 break;
>             }
>         }
>    }
>}
>
>template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator1
>search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>       _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
>{
>    return std::__1::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
>                         (__first1, __last1, __first2, __last2, __pred,
>                          typename std::iterator_traits<_ForwardIterator1>::iterator_category(),
>                          typename std::iterator_traits<_ForwardIterator2>::iterator_category());
>}
>
>template <class _ForwardIterator1, class _ForwardIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator1
>search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
>       _ForwardIterator2 __first2, _ForwardIterator2 __last2)
>{
>    typedef typename std::iterator_traits<_ForwardIterator1>::value_type __v1;
>    typedef typename std::iterator_traits<_ForwardIterator2>::value_type __v2;
>    return std::__1::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
>}
>
>
>
>template <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp>
>_ForwardIterator
>__search_n(_ForwardIterator __first, _ForwardIterator __last,
>           _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag)
>{
>    if (__count <= 0)
>        return __first;
>    while (true)
>    {
>
>        while (true)
>        {
>            if (__first == __last)
>                return __last;
>            if (__pred(*__first, __value_))
>                break;
>            ++__first;
>        }
>
>        _ForwardIterator __m = __first;
>        _Size __c(0);
>        while (true)
>        {
>            if (++__c == __count)
>                return __first;
>            if (++__m == __last)
>                return __last;
>            if (!__pred(*__m, __value_))
>            {
>                __first = __m;
>                ++__first;
>                break;
>            }
>        }
>    }
>}
>
>template <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp>
>_RandomAccessIterator
>__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last,
>           _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag)
>{
>    if (__count <= 0)
>        return __first;
>    _Size __len = static_cast<_Size>(__last - __first);
>    if (__len < __count)
>        return __last;
>    const _RandomAccessIterator __s = __last - (__count - 1);
>    while (true)
>    {
>
>        while (true)
>        {
>            if (__first >= __s)
>                return __last;
>            if (__pred(*__first, __value_))
>                break;
>            ++__first;
>        }
>
>        _RandomAccessIterator __m = __first;
>        _Size __c(0);
>        while (true)
>        {
>            if (++__c == __count)
>                return __first;
>             ++__m;
>            if (!__pred(*__m, __value_))
>            {
>                __first = __m;
>                ++__first;
>                break;
>            }
>        }
>    }
>}
>
>template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>search_n(_ForwardIterator __first, _ForwardIterator __last,
>         _Size __count, const _Tp& __value_, _BinaryPredicate __pred)
>{
>    return std::__1::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type>
>           (__first, __last, __count, __value_, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
>}
>
>template <class _ForwardIterator, class _Size, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type __v;
>    return std::__1::search_n(__first, __last, __count, __value_, __equal_to<__v, _Tp>());
>}
>
>
>
>template <class _Iter>
>struct __libcpp_is_trivial_iterator
>{
>    static const bool value = is_pointer<_Iter>::value;
>};
>
>template <class _Iter>
>struct __libcpp_is_trivial_iterator<move_iterator<_Iter> >
>{
>    static const bool value = is_pointer<_Iter>::value;
>};
>
>template <class _Iter>
>struct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> >
>{
>    static const bool value = is_pointer<_Iter>::value;
>};
>
>template <class _Iter>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Iter
>__unwrap_iter(_Iter __i)
>{
>    return __i;
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_trivially_copy_assignable<_Tp>::value,
>    _Tp*
>>::type
>__unwrap_iter(move_iterator<_Tp*> __i)
>{
>    return __i.base();
>}
>
>
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_trivially_copy_assignable<_Tp>::value,
>    _Tp*
>>::type
>__unwrap_iter(__wrap_iter<_Tp*> __i)
>{
>    return __i.base();
>}
>
>
>
>template <class _InputIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
>{
>    for (; __first != __last; ++__first, ++__result)
>        *__result = *__first;
>    return __result;
>}
>
>template <class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_same<typename remove_const<_Tp>::type, _Up>::value &&
>    is_trivially_copy_assignable<_Up>::value,
>    _Up*
>>::type
>__copy(_Tp* __first, _Tp* __last, _Up* __result)
>{
>    const size_t __n = static_cast<size_t>(__last - __first);
>    std::__1::memmove(__result, __first, __n * sizeof(_Up));
>    return __result + __n;
>}
>
>template <class _InputIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
>{
>    return std::__1::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
>}
>
>
>
>template <class _BidirectionalIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
>{
>    while (__first != __last)
>        *--__result = *--__last;
>    return __result;
>}
>
>template <class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_same<typename remove_const<_Tp>::type, _Up>::value &&
>    is_trivially_copy_assignable<_Up>::value,
>    _Up*
>>::type
>__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
>{
>    const size_t __n = static_cast<size_t>(__last - __first);
>    __result -= __n;
>    std::__1::memmove(__result, __first, __n * sizeof(_Up));
>    return __result;
>}
>
>template <class _BidirectionalIterator1, class _BidirectionalIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_BidirectionalIterator2
>copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
>              _BidirectionalIterator2 __result)
>{
>    return std::__1::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
>}
>
>
>
>template<class _InputIterator, class _OutputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>copy_if(_InputIterator __first, _InputIterator __last,
>        _OutputIterator __result, _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>    {
>        if (__pred(*__first))
>        {
>            *__result = *__first;
>            ++__result;
>        }
>    }
>    return __result;
>}
>
>
>
>template<class _InputIterator, class _Size, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    __is_input_iterator<_InputIterator>::value &&
>   !__is_random_access_iterator<_InputIterator>::value,
>    _OutputIterator
>>::type
>copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
>{
>    if (__n > 0)
>    {
>        *__result = *__first;
>        ++__result;
>        for (--__n; __n > 0; --__n)
>        {
>            ++__first;
>            *__result = *__first;
>            ++__result;
>        }
>    }
>    return __result;
>}
>
>template<class _InputIterator, class _Size, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    __is_random_access_iterator<_InputIterator>::value,
>    _OutputIterator
>>::type
>copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
>{
>    return std::__1::copy(__first, __first + __n, __result);
>}
>
>
>
>template <class _InputIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
>{
>    for (; __first != __last; ++__first, ++__result)
>        *__result = std::__1::move(*__first);
>    return __result;
>}
>
>template <class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_same<typename remove_const<_Tp>::type, _Up>::value &&
>    is_trivially_copy_assignable<_Up>::value,
>    _Up*
>>::type
>__move(_Tp* __first, _Tp* __last, _Up* __result)
>{
>    const size_t __n = static_cast<size_t>(__last - __first);
>    std::__1::memmove(__result, __first, __n * sizeof(_Up));
>    return __result + __n;
>}
>
>template <class _InputIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
>{
>    return std::__1::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
>}
>
>
>
>template <class _InputIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
>{
>    while (__first != __last)
>        *--__result = std::__1::move(*--__last);
>    return __result;
>}
>
>template <class _Tp, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_same<typename remove_const<_Tp>::type, _Up>::value &&
>    is_trivially_copy_assignable<_Up>::value,
>    _Up*
>>::type
>__move_backward(_Tp* __first, _Tp* __last, _Up* __result)
>{
>    const size_t __n = static_cast<size_t>(__last - __first);
>    __result -= __n;
>    std::__1::memmove(__result, __first, __n * sizeof(_Up));
>    return __result;
>}
>
>template <class _BidirectionalIterator1, class _BidirectionalIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_BidirectionalIterator2
>move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
>              _BidirectionalIterator2 __result)
>{
>    return std::__1::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
>}
>
>
>
>
>
>
>
>template <class _InputIterator, class _OutputIterator, class _UnaryOperation>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op)
>{
>    for (; __first != __last; ++__first, ++__result)
>        *__result = __op(*__first);
>    return __result;
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_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 <class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>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 <class _ForwardIterator, class _Predicate, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value)
>{
>    for (; __first != __last; ++__first)
>        if (__pred(*__first))
>            *__first = __new_value;
>}
>
>
>
>template <class _InputIterator, class _OutputIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
>             const _Tp& __old_value, const _Tp& __new_value)
>{
>    for (; __first != __last; ++__first, ++__result)
>        if (*__first == __old_value)
>            *__result = __new_value;
>        else
>            *__result = *__first;
>    return __result;
>}
>
>
>
>template <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
>                _Predicate __pred, const _Tp& __new_value)
>{
>    for (; __first != __last; ++__first, ++__result)
>        if (__pred(*__first))
>            *__result = __new_value;
>        else
>            *__result = *__first;
>    return __result;
>}
>
>
>
>template <class _OutputIterator, class _Size, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
>{
>    for (; __n > 0; ++__first, --__n)
>        *__first = __value_;
>    return __first;
>}
>
>template <class _Tp, class _Size, class _Up>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_integral<_Tp>::value && sizeof(_Tp) == 1 &&
>    !is_same<_Tp, bool>::value &&
>    is_integral<_Up>::value && sizeof(_Up) == 1,
>    _Tp*
>>::type
>__fill_n(_Tp* __first, _Size __n,_Up __value_)
>{
>    if (__n > 0)
>        std::__1::memset(__first, (unsigned char)__value_, (size_t)(__n));
>    return __first + __n;
>}
>
>template <class _OutputIterator, class _Size, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
>{
>   return std::__1::__fill_n(__first, __n, __value_);
>}
>
>
>
>template <class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag)
>{
>    for (; __first != __last; ++__first)
>        *__first = __value_;
>}
>
>template <class _RandomAccessIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag)
>{
>    std::__1::fill_n(__first, __last - __first, __value_);
>}
>
>template <class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
>{
>    std::__1::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category());
>}
>
>
>
>template <class _ForwardIterator, class _Generator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
>{
>    for (; __first != __last; ++__first)
>        *__first = __gen();
>}
>
>
>
>template <class _OutputIterator, class _Size, class _Generator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
>{
>    for (; __n > 0; ++__first, --__n)
>        *__first = __gen();
>    return __first;
>}
>
>
>
>template <class _ForwardIterator, class _Tp>
>_ForwardIterator
>remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
>{
>    __first = std::__1::find(__first, __last, __value_);
>    if (__first != __last)
>    {
>        _ForwardIterator __i = __first;
>        while (++__i != __last)
>        {
>            if (!(*__i == __value_))
>            {
>                *__first = std::__1::move(*__i);
>                ++__first;
>            }
>        }
>    }
>    return __first;
>}
>
>
>
>template <class _ForwardIterator, class _Predicate>
>_ForwardIterator
>remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
>{
>    __first = std::__1::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
>                           (__first, __last, __pred);
>    if (__first != __last)
>    {
>        _ForwardIterator __i = __first;
>        while (++__i != __last)
>        {
>            if (!__pred(*__i))
>            {
>                *__first = std::__1::move(*__i);
>                ++__first;
>            }
>        }
>    }
>    return __first;
>}
>
>
>
>template <class _InputIterator, class _OutputIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_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 <class _InputIterator, class _OutputIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_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 <class _ForwardIterator, class _BinaryPredicate>
>_ForwardIterator
>unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
>{
>    __first = std::__1::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type>
>                                 (__first, __last, __pred);
>    if (__first != __last)
>    {
>
>
>        _ForwardIterator __i = __first;
>        for (++__i; ++__i != __last;)
>            if (!__pred(*__first, *__i))
>                *++__first = std::__1::move(*__i);
>        ++__first;
>    }
>    return __first;
>}
>
>template <class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>unique(_ForwardIterator __first, _ForwardIterator __last)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type __v;
>    return std::__1::unique(__first, __last, __equal_to<__v>());
>}
>
>
>
>template <class _BinaryPredicate, class _InputIterator, class _OutputIterator>
>_OutputIterator
>__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
>              input_iterator_tag, output_iterator_tag)
>{
>    if (__first != __last)
>    {
>        typename iterator_traits<_InputIterator>::value_type __t(*__first);
>        *__result = __t;
>        ++__result;
>        while (++__first != __last)
>        {
>            if (!__pred(__t, *__first))
>            {
>                __t = *__first;
>                *__result = __t;
>                ++__result;
>            }
>        }
>    }
>    return __result;
>}
>
>template <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator>
>_OutputIterator
>__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
>              forward_iterator_tag, output_iterator_tag)
>{
>    if (__first != __last)
>    {
>        _ForwardIterator __i = __first;
>        *__result = *__i;
>        ++__result;
>        while (++__first != __last)
>        {
>            if (!__pred(*__i, *__first))
>            {
>                *__result = *__first;
>                ++__result;
>                __i = __first;
>            }
>        }
>    }
>    return __result;
>}
>
>template <class _BinaryPredicate, class _InputIterator, class _ForwardIterator>
>_ForwardIterator
>__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred,
>              input_iterator_tag, forward_iterator_tag)
>{
>    if (__first != __last)
>    {
>        *__result = *__first;
>        while (++__first != __last)
>            if (!__pred(*__result, *__first))
>                *++__result = *__first;
>        ++__result;
>    }
>    return __result;
>}
>
>template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred)
>{
>    return std::__1::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type>
>                              (__first, __last, __result, __pred,
>                               typename iterator_traits<_InputIterator>::iterator_category(),
>                               typename iterator_traits<_OutputIterator>::iterator_category());
>}
>
>template <class _InputIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
>{
>    typedef typename iterator_traits<_InputIterator>::value_type __v;
>    return std::__1::unique_copy(__first, __last, __result, __equal_to<__v>());
>}
>
>
>
>template <class _BidirectionalIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)
>{
>    while (__first != __last)
>    {
>        if (__first == --__last)
>            break;
>        swap(*__first, *__last);
>        ++__first;
>    }
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)
>{
>    if (__first != __last)
>        for (; __first < --__last; ++__first)
>            swap(*__first, *__last);
>}
>
>template <class _BidirectionalIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
>{
>    std::__1::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category());
>}
>
>
>
>template <class _BidirectionalIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
>{
>    for (; __first != __last; ++__result)
>        *__result = *--__last;
>    return __result;
>}
>
>
>
>template <class _ForwardIterator>
>_ForwardIterator
>__rotate_left(_ForwardIterator __first, _ForwardIterator __last)
>{
>    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
>    value_type __tmp = std::__1::move(*__first);
>    _ForwardIterator __lm1 = std::__1::move(std::__1::next(__first), __last, __first);
>    *__lm1 = std::__1::move(__tmp);
>    return __lm1;
>}
>
>template <class _BidirectionalIterator>
>_BidirectionalIterator
>__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
>{
>    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
>    _BidirectionalIterator __lm1 = std::__1::prev(__last);
>    value_type __tmp = std::__1::move(*__lm1);
>    _BidirectionalIterator __fp1 = std::__1::move_backward(__first, __lm1, __last);
>    *__first = std::__1::move(__tmp);
>    return __fp1;
>}
>
>template <class _ForwardIterator>
>_ForwardIterator
>__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
>{
>    _ForwardIterator __i = __middle;
>    while (true)
>    {
>        swap(*__first, *__i);
>        ++__first;
>        if (++__i == __last)
>            break;
>        if (__first == __middle)
>            __middle = __i;
>    }
>    _ForwardIterator __r = __first;
>    if (__first != __middle)
>    {
>        __i = __middle;
>        while (true)
>        {
>            swap(*__first, *__i);
>            ++__first;
>            if (++__i == __last)
>            {
>                if (__first == __middle)
>                    break;
>                __i = __middle;
>            }
>            else if (__first == __middle)
>                __middle = __i;
>        }
>    }
>    return __r;
>}
>
>template<typename _Integral>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Integral
>__gcd(_Integral __x, _Integral __y)
>{
>    do
>    {
>        _Integral __t = __x % __y;
>        __x = __y;
>        __y = __t;
>    } while (__y);
>    return __x;
>}
>
>template<typename _RandomAccessIterator>
>_RandomAccessIterator
>__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>
>    const difference_type __m1 = __middle - __first;
>    const difference_type __m2 = __last - __middle;
>    if (__m1 == __m2)
>    {
>        std::__1::swap_ranges(__first, __middle, __middle);
>        return __middle;
>    }
>    const difference_type __g = std::__1::__gcd(__m1, __m2);
>    for (_RandomAccessIterator __p = __first + __g; __p != __first;)
>    {
>        value_type __t(std::__1::move(*--__p));
>        _RandomAccessIterator __p1 = __p;
>        _RandomAccessIterator __p2 = __p1 + __m1;
>        do
>        {
>            *__p1 = std::__1::move(*__p2);
>            __p1 = __p2;
>            const difference_type __d = __last - __p2;
>            if (__m1 < __d)
>                __p2 += __m1;
>            else
>                __p2 = __first + (__m1 - __d);
>        } while (__p2 != __p);
>        *__p1 = std::__1::move(__t);
>    }
>    return __first + __m2;
>}
>
>template <class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
>         std::__1::forward_iterator_tag)
>{
>    typedef typename std::__1::iterator_traits<_ForwardIterator>::value_type value_type;
>    if (std::__1::is_trivially_move_assignable<value_type>::value)
>    {
>        if (std::__1::next(__first) == __middle)
>            return std::__1::__rotate_left(__first, __last);
>    }
>    return std::__1::__rotate_forward(__first, __middle, __last);
>}
>
>template <class _BidirectionalIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_BidirectionalIterator
>__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
>         std::__1::bidirectional_iterator_tag)
>{
>    typedef typename std::__1::iterator_traits<_BidirectionalIterator>::value_type value_type;
>    if (std::__1::is_trivially_move_assignable<value_type>::value)
>    {
>        if (std::__1::next(__first) == __middle)
>            return std::__1::__rotate_left(__first, __last);
>        if (std::__1::next(__middle) == __last)
>            return std::__1::__rotate_right(__first, __last);
>    }
>    return std::__1::__rotate_forward(__first, __middle, __last);
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_RandomAccessIterator
>__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
>         std::__1::random_access_iterator_tag)
>{
>    typedef typename std::__1::iterator_traits<_RandomAccessIterator>::value_type value_type;
>    if (std::__1::is_trivially_move_assignable<value_type>::value)
>    {
>        if (std::__1::next(__first) == __middle)
>            return std::__1::__rotate_left(__first, __last);
>        if (std::__1::next(__middle) == __last)
>            return std::__1::__rotate_right(__first, __last);
>        return std::__1::__rotate_gcd(__first, __middle, __last);
>    }
>    return std::__1::__rotate_forward(__first, __middle, __last);
>}
>
>template <class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
>{
>    if (__first == __middle)
>        return __last;
>    if (__middle == __last)
>        return __first;
>    return std::__1::__rotate(__first, __middle, __last,
>                           typename std::__1::iterator_traits<_ForwardIterator>::iterator_category());
>}
>
>
>
>template <class _ForwardIterator, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
>{
>    return std::__1::copy(__first, __middle, std::__1::copy(__middle, __last, __result));
>}
>
>
>
>template <class _ForwardIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>__min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
>{
>    if (__first != __last)
>    {
>        _ForwardIterator __i = __first;
>        while (++__i != __last)
>            if (__comp(*__i, *__first))
>                __first = __i;
>    }
>    return __first;
>}
>
>template <class _ForwardIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
>{
>    return __min_element(__first, __last, __comp);
>}
>
>template <class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>min_element(_ForwardIterator __first, _ForwardIterator __last)
>{
>    return __min_element(__first, __last,
>              __less<typename iterator_traits<_ForwardIterator>::value_type>());
>}
>
>
>
>template <class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>const _Tp&
>min(const _Tp& __a, const _Tp& __b, _Compare __comp)
>{
>    return __comp(__b, __a) ? __b : __a;
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>const _Tp&
>min(const _Tp& __a, const _Tp& __b)
>{
>    return std::__1::min(__a, __b, __less<_Tp>());
>}
>
>
>
>template<class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp
>min(initializer_list<_Tp> __t, _Compare __comp)
>{
>    return *__min_element(__t.begin(), __t.end(), __comp);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp
>min(initializer_list<_Tp> __t)
>{
>    return *__min_element(__t.begin(), __t.end(), __less<_Tp>());
>}
>
>
>
>
>
>template <class _ForwardIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>__max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
>{
>    if (__first != __last)
>    {
>        _ForwardIterator __i = __first;
>        while (++__i != __last)
>            if (__comp(*__first, *__i))
>                __first = __i;
>    }
>    return __first;
>}
>
>
>template <class _ForwardIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
>{
>    return __max_element(__first, __last, __comp);
>}
>
>template <class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>max_element(_ForwardIterator __first, _ForwardIterator __last)
>{
>    return __max_element(__first, __last,
>              __less<typename iterator_traits<_ForwardIterator>::value_type>());
>}
>
>
>
>template <class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>const _Tp&
>max(const _Tp& __a, const _Tp& __b, _Compare __comp)
>{
>    return __comp(__a, __b) ? __b : __a;
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>const _Tp&
>max(const _Tp& __a, const _Tp& __b)
>{
>    return std::__1::max(__a, __b, __less<_Tp>());
>}
>
>
>
>template<class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp
>max(initializer_list<_Tp> __t, _Compare __comp)
>{
>    return *__max_element(__t.begin(), __t.end(), __comp);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Tp
>max(initializer_list<_Tp> __t)
>{
>    return *__max_element(__t.begin(), __t.end(), __less<_Tp>());
>}
>
>
>
>
>
>template <class _ForwardIterator, class _Compare>
>std::pair<_ForwardIterator, _ForwardIterator>
>minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
>{
>  std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first);
>  if (__first != __last)
>  {
>      if (++__first != __last)
>      {
>          if (__comp(*__first, *__result.first))
>              __result.first = __first;
>          else
>              __result.second = __first;
>          while (++__first != __last)
>          {
>              _ForwardIterator __i = __first;
>              if (++__first == __last)
>              {
>                  if (__comp(*__i, *__result.first))
>                      __result.first = __i;
>                  else if (!__comp(*__i, *__result.second))
>                      __result.second = __i;
>                  break;
>              }
>              else
>              {
>                  if (__comp(*__first, *__i))
>                  {
>                      if (__comp(*__first, *__result.first))
>                          __result.first = __first;
>                      if (!__comp(*__i, *__result.second))
>                          __result.second = __i;
>                  }
>                  else
>                  {
>                      if (__comp(*__i, *__result.first))
>                          __result.first = __i;
>                      if (!__comp(*__first, *__result.second))
>                          __result.second = __first;
>                  }
>              }
>          }
>      }
>  }
>  return __result;
>}
>
>template <class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>std::pair<_ForwardIterator, _ForwardIterator>
>minmax_element(_ForwardIterator __first, _ForwardIterator __last)
>{
>    return std::__1::minmax_element(__first, __last,
>              __less<typename iterator_traits<_ForwardIterator>::value_type>());
>}
>
>
>
>template<class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<const _Tp&, const _Tp&>
>minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
>{
>    return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
>                              pair<const _Tp&, const _Tp&>(__a, __b);
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<const _Tp&, const _Tp&>
>minmax(const _Tp& __a, const _Tp& __b)
>{
>    return std::__1::minmax(__a, __b, __less<_Tp>());
>}
>
>
>
>template<class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<_Tp, _Tp>
>minmax(initializer_list<_Tp> __t, _Compare __comp)
>{
>    typedef typename initializer_list<_Tp>::const_iterator _Iter;
>    _Iter __first = __t.begin();
>    _Iter __last = __t.end();
>    std::pair<_Tp, _Tp> __result ( *__first, *__first );
>
>    ++__first;
>    if (__t.size() % 2 == 0)
>    {
>        if (__comp(*__first, __result.first))
>            __result.first = *__first;
>        else
>            __result.second = *__first;
>        ++__first;
>    }
>
>    while (__first != __last)
>    {
>        _Tp __prev = *__first++;
>        if (__comp(__prev, *__first)) {
>            if (__comp(__prev, __result.first)) __result.first = __prev;
>            if (__comp(__result.second, *__first)) __result.second = *__first;
>            }
>        else {
>            if (__comp(*__first, __result.first)) __result.first = *__first;
>            if (__comp(__result.second, __prev)) __result.second = __prev;
>            }
>
>        __first++;
>    }
>    return __result;
>}
>
>template<class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<_Tp, _Tp>
>minmax(initializer_list<_Tp> __t)
>{
>    return std::__1::minmax(__t, __less<_Tp>());
>}
>
>
>
>
>
>
>
>template <unsigned long long _Xp, size_t _Rp>
>struct __log2_imp
>{
>    static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
>                                           : __log2_imp<_Xp, _Rp - 1>::value;
>};
>
>template <unsigned long long _Xp>
>struct __log2_imp<_Xp, 0>
>{
>    static const size_t value = 0;
>};
>
>template <size_t _Rp>
>struct __log2_imp<0, _Rp>
>{
>    static const size_t value = _Rp + 1;
>};
>
>template <class _UI, _UI _Xp>
>struct __log2
>{
>    static const size_t value = __log2_imp<_Xp,
>                                         sizeof(_UI) * 8 - 1>::value;
>};
>
>template<class _Engine, class _UIntType>
>class __independent_bits_engine
>{
>public:
>
>    typedef _UIntType result_type;
>
>private:
>    typedef typename _Engine::result_type _Engine_result_type;
>    typedef typename conditional
>        <
>            sizeof(_Engine_result_type) <= sizeof(result_type),
>                result_type,
>                _Engine_result_type
>        >::type _Working_result_type;
>
>    _Engine& __e_;
>    size_t __w_;
>    size_t __w0_;
>    size_t __n_;
>    size_t __n0_;
>    _Working_result_type __y0_;
>    _Working_result_type __y1_;
>    _Engine_result_type __mask0_;
>    _Engine_result_type __mask1_;
>
>
>
>
>
>    static constexpr const _Working_result_type _Rp = _Engine::max() - _Engine::min()
>                                                      + _Working_result_type(1);
>
>    static constexpr const size_t __m = __log2<_Working_result_type, _Rp>::value;
>    static constexpr const size_t _WDt = numeric_limits<_Working_result_type>::digits;
>    static constexpr const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
>
>public:
>
>    __independent_bits_engine(_Engine& __e, size_t __w);
>
>
>    result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
>
>private:
>    result_type __eval(false_type);
>    result_type __eval(true_type);
>};
>
>template<class _Engine, class _UIntType>
>__independent_bits_engine<_Engine, _UIntType>
>    ::__independent_bits_engine(_Engine& __e, size_t __w)
>        : __e_(__e),
>          __w_(__w)
>{
>    __n_ = __w_ / __m + (__w_ % __m != 0);
>    __w0_ = __w_ / __n_;
>    if (_Rp == 0)
>        __y0_ = _Rp;
>    else if (__w0_ < _WDt)
>        __y0_ = (_Rp >> __w0_) << __w0_;
>    else
>        __y0_ = 0;
>    if (_Rp - __y0_ > __y0_ / __n_)
>    {
>        ++__n_;
>        __w0_ = __w_ / __n_;
>        if (__w0_ < _WDt)
>            __y0_ = (_Rp >> __w0_) << __w0_;
>        else
>            __y0_ = 0;
>    }
>    __n0_ = __n_ - __w_ % __n_;
>    if (__w0_ < _WDt - 1)
>        __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1);
>    else
>        __y1_ = 0;
>    __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) :
>                          _Engine_result_type(0);
>    __mask1_ = __w0_ < _EDt - 1 ?
>                               _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) :
>                               _Engine_result_type(~0);
>}
>
>template<class _Engine, class _UIntType>
>inline
>_UIntType
>__independent_bits_engine<_Engine, _UIntType>::__eval(false_type)
>{
>    return static_cast<result_type>(__e_() & __mask0_);
>}
>
>template<class _Engine, class _UIntType>
>_UIntType
>__independent_bits_engine<_Engine, _UIntType>::__eval(true_type)
>{
>    result_type _Sp = 0;
>    for (size_t __k = 0; __k < __n0_; ++__k)
>    {
>        _Engine_result_type __u;
>        do
>        {
>            __u = __e_() - _Engine::min();
>        } while (__u >= __y0_);
>        if (__w0_ < _WDt)
>            _Sp <<= __w0_;
>        else
>            _Sp = 0;
>        _Sp += __u & __mask0_;
>    }
>    for (size_t __k = __n0_; __k < __n_; ++__k)
>    {
>        _Engine_result_type __u;
>        do
>        {
>            __u = __e_() - _Engine::min();
>        } while (__u >= __y1_);
>        if (__w0_ < _WDt - 1)
>            _Sp <<= __w0_ + 1;
>        else
>            _Sp = 0;
>        _Sp += __u & __mask1_;
>    }
>    return _Sp;
>}
>
>
>
>template<class _IntType = int>
>class uniform_int_distribution
>{
>public:
>
>    typedef _IntType result_type;
>
>    class param_type
>    {
>        result_type __a_;
>        result_type __b_;
>    public:
>        typedef uniform_int_distribution distribution_type;
>
>        explicit param_type(result_type __a = 0,
>                            result_type __b = numeric_limits<result_type>::max())
>            : __a_(__a), __b_(__b) {}
>
>        result_type a() const {return __a_;}
>        result_type b() const {return __b_;}
>
>        friend bool operator==(const param_type& __x, const param_type& __y)
>            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
>        friend bool operator!=(const param_type& __x, const param_type& __y)
>            {return !(__x == __y);}
>    };
>
>private:
>    param_type __p_;
>
>public:
>
>    explicit uniform_int_distribution(result_type __a = 0,
>                                      result_type __b = numeric_limits<result_type>::max())
>        : __p_(param_type(__a, __b)) {}
>    explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
>    void reset() {}
>
>
>    template<class _URNG> result_type operator()(_URNG& __g)
>        {return (*this)(__g, __p_);}
>    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
>
>
>    result_type a() const {return __p_.a();}
>    result_type b() const {return __p_.b();}
>
>    param_type param() const {return __p_;}
>    void param(const param_type& __p) {__p_ = __p;}
>
>    result_type min() const {return a();}
>    result_type max() const {return b();}
>
>    friend bool operator==(const uniform_int_distribution& __x,
>                           const uniform_int_distribution& __y)
>        {return __x.__p_ == __y.__p_;}
>    friend bool operator!=(const uniform_int_distribution& __x,
>                           const uniform_int_distribution& __y)
>            {return !(__x == __y);}
>};
>
>template<class _IntType>
>template<class _URNG>
>typename uniform_int_distribution<_IntType>::result_type
>uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
>{
>    typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t),
>                                            uint32_t, uint64_t>::type _UIntType;
>    const _UIntType _Rp = __p.b() - __p.a() + _UIntType(1);
>    if (_Rp == 1)
>        return __p.a();
>    const size_t _Dt = numeric_limits<_UIntType>::digits;
>    typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
>    if (_Rp == 0)
>        return static_cast<result_type>(_Eng(__g, _Dt)());
>    size_t __w = _Dt - __clz(_Rp) - 1;
>    if ((_Rp & (_UIntType(~0) >> (_Dt - __w))) != 0)
>        ++__w;
>    _Eng __e(__g, __w);
>    _UIntType __u;
>    do
>    {
>        __u = __e();
>    } while (__u >= _Rp);
>    return static_cast<result_type>(__u + __p.a());
>}
>
>class __attribute__ ((__visibility__("default"))) __rs_default;
>
>__attribute__ ((__visibility__("default"))) __rs_default __rs_get();
>
>class __attribute__ ((__visibility__("default"))) __rs_default
>{
>    static unsigned __c_;
>
>    __rs_default();
>public:
>    typedef uint_fast32_t result_type;
>
>    static const result_type _Min = 0;
>    static const result_type _Max = 0xFFFFFFFF;
>
>    __rs_default(const __rs_default&);
>    ~__rs_default();
>
>    result_type operator()();
>
>    static constexpr result_type min() {return _Min;}
>    static constexpr result_type max() {return _Max;}
>
>    friend __attribute__ ((__visibility__("default"))) __rs_default __rs_get();
>};
>
>__attribute__ ((__visibility__("default"))) __rs_default __rs_get();
>
>template <class _RandomAccessIterator>
>void
>random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    typedef uniform_int_distribution<ptrdiff_t> _Dp;
>    typedef typename _Dp::param_type _Pp;
>    difference_type __d = __last - __first;
>    if (__d > 1)
>    {
>        _Dp __uid;
>        __rs_default __g = __rs_get();
>        for (--__last, --__d; __first < __last; ++__first, --__d)
>        {
>            difference_type __i = __uid(__g, _Pp(0, __d));
>            if (__i != difference_type(0))
>                swap(*__first, *(__first + __i));
>        }
>    }
>}
>
>template <class _RandomAccessIterator, class _RandomNumberGenerator>
>void
>random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
>
>               _RandomNumberGenerator&& __rand)
>
>
>
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    difference_type __d = __last - __first;
>    if (__d > 1)
>    {
>        for (--__last; __first < __last; ++__first, --__d)
>        {
>            difference_type __i = __rand(__d);
>            swap(*__first, *(__first + __i));
>        }
>    }
>}
>
>template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
>    void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
>
>                 _UniformRandomNumberGenerator&& __g)
>
>
>
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    typedef uniform_int_distribution<ptrdiff_t> _Dp;
>    typedef typename _Dp::param_type _Pp;
>    difference_type __d = __last - __first;
>    if (__d > 1)
>    {
>        _Dp __uid;
>        for (--__last, --__d; __first < __last; ++__first, --__d)
>        {
>            difference_type __i = __uid(__g, _Pp(0, __d));
>            if (__i != difference_type(0))
>                swap(*__first, *(__first + __i));
>        }
>    }
>}
>
>template <class _InputIterator, class _Predicate>
>bool
>is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>        if (!__pred(*__first))
>            break;
>    for (; __first != __last; ++__first)
>        if (__pred(*__first))
>            return false;
>    return true;
>}
>
>
>
>template <class _Predicate, class _ForwardIterator>
>_ForwardIterator
>__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag)
>{
>    while (true)
>    {
>        if (__first == __last)
>            return __first;
>        if (!__pred(*__first))
>            break;
>        ++__first;
>    }
>    for (_ForwardIterator __p = __first; ++__p != __last;)
>    {
>        if (__pred(*__p))
>        {
>            swap(*__first, *__p);
>            ++__first;
>        }
>    }
>    return __first;
>}
>
>template <class _Predicate, class _BidirectionalIterator>
>_BidirectionalIterator
>__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
>            bidirectional_iterator_tag)
>{
>    while (true)
>    {
>        while (true)
>        {
>            if (__first == __last)
>                return __first;
>            if (!__pred(*__first))
>                break;
>            ++__first;
>        }
>        do
>        {
>            if (__first == --__last)
>                return __first;
>        } while (!__pred(*__last));
>        swap(*__first, *__last);
>        ++__first;
>    }
>}
>
>template <class _ForwardIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
>{
>    return std::__1::__partition<typename add_lvalue_reference<_Predicate>::type>
>                            (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
>}
>
>
>
>template <class _InputIterator, class _OutputIterator1,
>          class _OutputIterator2, class _Predicate>
>pair<_OutputIterator1, _OutputIterator2>
>partition_copy(_InputIterator __first, _InputIterator __last,
>               _OutputIterator1 __out_true, _OutputIterator2 __out_false,
>               _Predicate __pred)
>{
>    for (; __first != __last; ++__first)
>    {
>        if (__pred(*__first))
>        {
>            *__out_true = *__first;
>            ++__out_true;
>        }
>        else
>        {
>            *__out_false = *__first;
>            ++__out_false;
>        }
>    }
>    return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
>}
>
>
>
>template<class _ForwardIterator, class _Predicate>
>_ForwardIterator
>partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
>{
>    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
>    difference_type __len = std::__1::distance(__first, __last);
>    while (__len != 0)
>    {
>        difference_type __l2 = __len / 2;
>        _ForwardIterator __m = __first;
>        std::__1::advance(__m, __l2);
>        if (__pred(*__m))
>        {
>            __first = ++__m;
>            __len -= __l2 + 1;
>        }
>        else
>            __len = __l2;
>    }
>    return __first;
>}
>
>
>
>template <class _Predicate, class _ForwardIterator, class _Distance, class _Pair>
>_ForwardIterator
>__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
>                   _Distance __len, _Pair __p, forward_iterator_tag __fit)
>{
>
>
>    if (__len == 1)
>        return __first;
>    if (__len == 2)
>    {
>        _ForwardIterator __m = __first;
>        if (__pred(*++__m))
>        {
>            swap(*__first, *__m);
>            return __m;
>        }
>        return __first;
>    }
>    if (__len <= __p.second)
>    {
>        typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
>        __destruct_n __d(0);
>        unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
>
>
>        value_type* __t = __p.first;
>        ::new(__t) value_type(std::__1::move(*__first));
>        __d.__incr((value_type*)0);
>        ++__t;
>        _ForwardIterator __i = __first;
>        while (++__i != __last)
>        {
>            if (__pred(*__i))
>            {
>                *__first = std::__1::move(*__i);
>                ++__first;
>            }
>            else
>            {
>                ::new(__t) value_type(std::__1::move(*__i));
>                __d.__incr((value_type*)0);
>                ++__t;
>            }
>        }
>
>
>        __i = __first;
>        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
>            *__i = std::__1::move(*__t2);
>
>        return __first;
>    }
>
>
>    _ForwardIterator __m = __first;
>    _Distance __len2 = __len / 2;
>    std::__1::advance(__m, __len2);
>
>
>
>    typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
>    _ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit);
>
>
>
>    _ForwardIterator __m1 = __m;
>    _ForwardIterator __second_false = __last;
>    _Distance __len_half = __len - __len2;
>    while (__pred(*__m1))
>    {
>        if (++__m1 == __last)
>            goto __second_half_done;
>        --__len_half;
>    }
>
>
>    __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit);
>__second_half_done:
>
>
>    return std::__1::rotate(__first_false, __m, __second_false);
>
>
>}
>
>struct __return_temporary_buffer
>{
>    template <class _Tp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__)) void operator()(_Tp* __p) const {std::__1::return_temporary_buffer(__p);}
>};
>
>template <class _Predicate, class _ForwardIterator>
>_ForwardIterator
>__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
>                   forward_iterator_tag)
>{
>    const unsigned __alloc_limit = 3;
>
>    while (true)
>    {
>        if (__first == __last)
>            return __first;
>        if (!__pred(*__first))
>            break;
>        ++__first;
>    }
>
>
>    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
>    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
>    difference_type __len = std::__1::distance(__first, __last);
>    pair<value_type*, ptrdiff_t> __p(0, 0);
>    unique_ptr<value_type, __return_temporary_buffer> __h;
>    if (__len >= __alloc_limit)
>    {
>        __p = std::__1::get_temporary_buffer<value_type>(__len);
>        __h.reset(__p.first);
>    }
>    return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
>                             (__first, __last, __pred, __len, __p, forward_iterator_tag());
>}
>
>template <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair>
>_BidirectionalIterator
>__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
>                   _Distance __len, _Pair __p, bidirectional_iterator_tag __bit)
>{
>
>
>
>    if (__len == 2)
>    {
>        swap(*__first, *__last);
>        return __last;
>    }
>    if (__len == 3)
>    {
>        _BidirectionalIterator __m = __first;
>        if (__pred(*++__m))
>        {
>            swap(*__first, *__m);
>            swap(*__m, *__last);
>            return __last;
>        }
>        swap(*__m, *__last);
>        swap(*__first, *__m);
>        return __m;
>    }
>    if (__len <= __p.second)
>    {
>        typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
>        __destruct_n __d(0);
>        unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
>
>
>        value_type* __t = __p.first;
>        ::new(__t) value_type(std::__1::move(*__first));
>        __d.__incr((value_type*)0);
>        ++__t;
>        _BidirectionalIterator __i = __first;
>        while (++__i != __last)
>        {
>            if (__pred(*__i))
>            {
>                *__first = std::__1::move(*__i);
>                ++__first;
>            }
>            else
>            {
>                ::new(__t) value_type(std::__1::move(*__i));
>                __d.__incr((value_type*)0);
>                ++__t;
>            }
>        }
>
>        *__first = std::__1::move(*__i);
>        __i = ++__first;
>
>
>        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
>            *__i = std::__1::move(*__t2);
>
>        return __first;
>    }
>
>
>    _BidirectionalIterator __m = __first;
>    _Distance __len2 = __len / 2;
>    std::__1::advance(__m, __len2);
>
>
>
>    _BidirectionalIterator __m1 = __m;
>    _BidirectionalIterator __first_false = __first;
>    _Distance __len_half = __len2;
>    while (!__pred(*--__m1))
>    {
>        if (__m1 == __first)
>            goto __first_half_done;
>        --__len_half;
>    }
>
>
>    typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
>    __first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit);
>__first_half_done:
>
>
>
>    __m1 = __m;
>    _BidirectionalIterator __second_false = __last;
>    ++__second_false;
>    __len_half = __len - __len2;
>    while (__pred(*__m1))
>    {
>        if (++__m1 == __last)
>            goto __second_half_done;
>        --__len_half;
>    }
>
>
>    __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit);
>__second_half_done:
>
>
>    return std::__1::rotate(__first_false, __m, __second_false);
>
>
>}
>
>template <class _Predicate, class _BidirectionalIterator>
>_BidirectionalIterator
>__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
>                   bidirectional_iterator_tag)
>{
>    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
>    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
>    const difference_type __alloc_limit = 4;
>
>    while (true)
>    {
>        if (__first == __last)
>            return __first;
>        if (!__pred(*__first))
>            break;
>        ++__first;
>    }
>
>
>    do
>    {
>        if (__first == --__last)
>            return __first;
>    } while (!__pred(*__last));
>
>
>
>
>    difference_type __len = std::__1::distance(__first, __last) + 1;
>    pair<value_type*, ptrdiff_t> __p(0, 0);
>    unique_ptr<value_type, __return_temporary_buffer> __h;
>    if (__len >= __alloc_limit)
>    {
>        __p = std::__1::get_temporary_buffer<value_type>(__len);
>        __h.reset(__p.first);
>    }
>    return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
>                             (__first, __last, __pred, __len, __p, bidirectional_iterator_tag());
>}
>
>template <class _ForwardIterator, class _Predicate>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
>{
>    return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
>                             (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
>}
>
>
>
>template <class _ForwardIterator, class _Compare>
>_ForwardIterator
>is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
>{
>    if (__first != __last)
>    {
>        _ForwardIterator __i = __first;
>        while (++__i != __last)
>        {
>            if (__comp(*__i, *__first))
>                return __i;
>            __first = __i;
>        }
>    }
>    return __last;
>}
>
>template<class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
>{
>    return std::__1::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
>}
>
>
>
>template <class _ForwardIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
>{
>    return std::__1::is_sorted_until(__first, __last, __comp) == __last;
>}
>
>template<class _ForwardIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>is_sorted(_ForwardIterator __first, _ForwardIterator __last)
>{
>    return std::__1::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
>}
>
>
>
>
>
>template <class _Compare, class _ForwardIterator>
>unsigned
>__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c)
>{
>    unsigned __r = 0;
>    if (!__c(*__y, *__x))
>    {
>        if (!__c(*__z, *__y))
>            return __r;
>
>        swap(*__y, *__z);
>        __r = 1;
>        if (__c(*__y, *__x))
>        {
>            swap(*__x, *__y);
>            __r = 2;
>        }
>        return __r;
>    }
>    if (__c(*__z, *__y))
>    {
>        swap(*__x, *__z);
>        __r = 1;
>        return __r;
>    }
>    swap(*__x, *__y);
>    __r = 1;
>    if (__c(*__z, *__y))
>    {
>        swap(*__y, *__z);
>        __r = 2;
>    }
>    return __r;
>}
>
>
>
>template <class _Compare, class _ForwardIterator>
>unsigned
>__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
>            _ForwardIterator __x4, _Compare __c)
>{
>    unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c);
>    if (__c(*__x4, *__x3))
>    {
>        swap(*__x3, *__x4);
>        ++__r;
>        if (__c(*__x3, *__x2))
>        {
>            swap(*__x2, *__x3);
>            ++__r;
>            if (__c(*__x2, *__x1))
>            {
>                swap(*__x1, *__x2);
>                ++__r;
>            }
>        }
>    }
>    return __r;
>}
>
>
>
>template <class _Compare, class _ForwardIterator>
>unsigned
>__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
>            _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c)
>{
>    unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c);
>    if (__c(*__x5, *__x4))
>    {
>        swap(*__x4, *__x5);
>        ++__r;
>        if (__c(*__x4, *__x3))
>        {
>            swap(*__x3, *__x4);
>            ++__r;
>            if (__c(*__x3, *__x2))
>            {
>                swap(*__x2, *__x3);
>                ++__r;
>                if (__c(*__x2, *__x1))
>                {
>                    swap(*__x1, *__x2);
>                    ++__r;
>                }
>            }
>        }
>    }
>    return __r;
>}
>
>
>template <class _Compare, class _BirdirectionalIterator>
>void
>__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
>{
>    _BirdirectionalIterator __lm1 = __last;
>    for (--__lm1; __first != __lm1; ++__first)
>    {
>        _BirdirectionalIterator __i = std::__1::min_element<_BirdirectionalIterator,
>                                                        typename add_lvalue_reference<_Compare>::type>
>                                                       (__first, __last, __comp);
>        if (__i != __first)
>            swap(*__first, *__i);
>    }
>}
>
>template <class _Compare, class _BirdirectionalIterator>
>void
>__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
>{
>    typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
>    if (__first != __last)
>    {
>        _BirdirectionalIterator __i = __first;
>        for (++__i; __i != __last; ++__i)
>        {
>            _BirdirectionalIterator __j = __i;
>            value_type __t(std::__1::move(*__j));
>            for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j)
>                *__j = std::__1::move(*__k);
>            *__j = std::__1::move(__t);
>        }
>    }
>}
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    _RandomAccessIterator __j = __first+2;
>    __sort3<_Compare>(__first, __first+1, __j, __comp);
>    for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
>    {
>        if (__comp(*__i, *__j))
>        {
>            value_type __t(std::__1::move(*__i));
>            _RandomAccessIterator __k = __j;
>            __j = __i;
>            do
>            {
>                *__j = std::__1::move(*__k);
>                __j = __k;
>            } while (__j != __first && __comp(__t, *--__k));
>            *__j = std::__1::move(__t);
>        }
>        __j = __i;
>    }
>}
>
>template <class _Compare, class _RandomAccessIterator>
>bool
>__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>    switch (__last - __first)
>    {
>    case 0:
>    case 1:
>        return true;
>    case 2:
>        if (__comp(*--__last, *__first))
>            swap(*__first, *__last);
>        return true;
>    case 3:
>        std::__1::__sort3<_Compare>(__first, __first+1, --__last, __comp);
>        return true;
>    case 4:
>        std::__1::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
>        return true;
>    case 5:
>        std::__1::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
>        return true;
>    }
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    _RandomAccessIterator __j = __first+2;
>    __sort3<_Compare>(__first, __first+1, __j, __comp);
>    const unsigned __limit = 8;
>    unsigned __count = 0;
>    for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
>    {
>        if (__comp(*__i, *__j))
>        {
>            value_type __t(std::__1::move(*__i));
>            _RandomAccessIterator __k = __j;
>            __j = __i;
>            do
>            {
>                *__j = std::__1::move(*__k);
>                __j = __k;
>            } while (__j != __first && __comp(__t, *--__k));
>            *__j = std::__1::move(__t);
>            if (++__count == __limit)
>                return ++__i == __last;
>        }
>        __j = __i;
>    }
>    return true;
>}
>
>template <class _Compare, class _BirdirectionalIterator>
>void
>__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1,
>                      typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp)
>{
>    typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
>    if (__first1 != __last1)
>    {
>        __destruct_n __d(0);
>        unique_ptr<value_type, __destruct_n&> __h(__first2, __d);
>        value_type* __last2 = __first2;
>        ::new(__last2) value_type(std::__1::move(*__first1));
>        __d.__incr((value_type*)0);
>        for (++__last2; ++__first1 != __last1; ++__last2)
>        {
>            value_type* __j2 = __last2;
>            value_type* __i2 = __j2;
>            if (__comp(*__first1, *--__i2))
>            {
>                ::new(__j2) value_type(std::__1::move(*__i2));
>                __d.__incr((value_type*)0);
>                for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2)
>                    *__j2 = std::__1::move(*__i2);
>                *__j2 = std::__1::move(*__first1);
>            }
>            else
>            {
>                ::new(__j2) value_type(std::__1::move(*__first1));
>                __d.__incr((value_type*)0);
>            }
>        }
>        __h.release();
>    }
>}
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
>                                    is_trivially_copy_assignable<value_type>::value ? 30 : 6;
>    while (true)
>    {
>    __restart:
>        difference_type __len = __last - __first;
>        switch (__len)
>        {
>        case 0:
>        case 1:
>            return;
>        case 2:
>            if (__comp(*--__last, *__first))
>                swap(*__first, *__last);
>            return;
>        case 3:
>            std::__1::__sort3<_Compare>(__first, __first+1, --__last, __comp);
>            return;
>        case 4:
>            std::__1::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
>            return;
>        case 5:
>            std::__1::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
>            return;
>        }
>        if (__len <= __limit)
>        {
>            std::__1::__insertion_sort_3<_Compare>(__first, __last, __comp);
>            return;
>        }
>
>        _RandomAccessIterator __m = __first;
>        _RandomAccessIterator __lm1 = __last;
>        --__lm1;
>        unsigned __n_swaps;
>        {
>        difference_type __delta;
>        if (__len >= 1000)
>        {
>            __delta = __len/2;
>            __m += __delta;
>            __delta /= 2;
>            __n_swaps = std::__1::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp);
>        }
>        else
>        {
>            __delta = __len/2;
>            __m += __delta;
>            __n_swaps = std::__1::__sort3<_Compare>(__first, __m, __lm1, __comp);
>        }
>        }
>
>
>
>        _RandomAccessIterator __i = __first;
>        _RandomAccessIterator __j = __lm1;
>
>
>
>        if (!__comp(*__i, *__m))
>        {
>
>
>            while (true)
>            {
>                if (__i == --__j)
>                {
>
>
>                    ++__i;
>                    __j = __last;
>                    if (!__comp(*__first, *--__j))
>                    {
>                        while (true)
>                        {
>                            if (__i == __j)
>                                return;
>                            if (__comp(*__first, *__i))
>                            {
>                                swap(*__i, *__j);
>                                ++__n_swaps;
>                                ++__i;
>                                break;
>                            }
>                            ++__i;
>                        }
>                    }
>
>                    if (__i == __j)
>                        return;
>                    while (true)
>                    {
>                        while (!__comp(*__first, *__i))
>                            ++__i;
>                        while (__comp(*__first, *--__j))
>                            ;
>                        if (__i >= __j)
>                            break;
>                        swap(*__i, *__j);
>                        ++__n_swaps;
>                        ++__i;
>                    }
>
>
>
>                    __first = __i;
>                    goto __restart;
>                }
>                if (__comp(*__j, *__m))
>                {
>                    swap(*__i, *__j);
>                    ++__n_swaps;
>                    break;
>                }
>            }
>        }
>
>        ++__i;
>
>
>        if (__i < __j)
>        {
>
>
>            while (true)
>            {
>
>                while (__comp(*__i, *__m))
>                    ++__i;
>
>                while (!__comp(*--__j, *__m))
>                    ;
>                if (__i > __j)
>                    break;
>                swap(*__i, *__j);
>                ++__n_swaps;
>
>
>                if (__m == __i)
>                    __m = __j;
>                ++__i;
>            }
>        }
>
>        if (__i != __m && __comp(*__m, *__i))
>        {
>            swap(*__i, *__m);
>            ++__n_swaps;
>        }
>
>
>        if (__n_swaps == 0)
>        {
>            bool __fs = std::__1::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
>            if (std::__1::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp))
>            {
>                if (__fs)
>                    return;
>                __last = __i;
>                continue;
>            }
>            else
>            {
>                if (__fs)
>                {
>                    __first = ++__i;
>                    continue;
>                }
>            }
>        }
>
>        if (__i - __first < __last - __i)
>        {
>            std::__1::__sort<_Compare>(__first, __i, __comp);
>
>            __first = ++__i;
>        }
>        else
>        {
>            std::__1::__sort<_Compare>(__i+1, __last, __comp);
>
>            __last = __i;
>        }
>    }
>}
>
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __sort<_Comp_ref>(__first, __last, __comp);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    std::__1::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>sort(_Tp** __first, _Tp** __last)
>{
>    std::__1::sort((size_t*)__first, (size_t*)__last, __less<size_t>());
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last)
>{
>    std::__1::sort(__first.base(), __last.base());
>}
>
>template <class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp)
>{
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    std::__1::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp);
>}
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>template <class _Compare, class _ForwardIterator, class _Tp>
>_ForwardIterator
>__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
>    difference_type __len = std::__1::distance(__first, __last);
>    while (__len != 0)
>    {
>        difference_type __l2 = __len / 2;
>        _ForwardIterator __m = __first;
>        std::__1::advance(__m, __l2);
>        if (__comp(*__m, __value_))
>        {
>            __first = ++__m;
>            __len -= __l2 + 1;
>        }
>        else
>            __len = __l2;
>    }
>    return __first;
>}
>
>template <class _ForwardIterator, class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp);
>
>}
>
>template <class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
>{
>    return std::__1::lower_bound(__first, __last, __value_,
>                             __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
>}
>
>
>
>template <class _Compare, class _ForwardIterator, class _Tp>
>_ForwardIterator
>__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
>    difference_type __len = std::__1::distance(__first, __last);
>    while (__len != 0)
>    {
>        difference_type __l2 = __len / 2;
>        _ForwardIterator __m = __first;
>        std::__1::advance(__m, __l2);
>        if (__comp(__value_, *__m))
>            __len = __l2;
>        else
>        {
>            __first = ++__m;
>            __len -= __l2 + 1;
>        }
>    }
>    return __first;
>}
>
>template <class _ForwardIterator, class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp);
>
>}
>
>template <class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_ForwardIterator
>upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
>{
>    return std::__1::upper_bound(__first, __last, __value_,
>                             __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _ForwardIterator, class _Tp>
>pair<_ForwardIterator, _ForwardIterator>
>__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
>    difference_type __len = std::__1::distance(__first, __last);
>    while (__len != 0)
>    {
>        difference_type __l2 = __len / 2;
>        _ForwardIterator __m = __first;
>        std::__1::advance(__m, __l2);
>        if (__comp(*__m, __value_))
>        {
>            __first = ++__m;
>            __len -= __l2 + 1;
>        }
>        else if (__comp(__value_, *__m))
>        {
>            __last = __m;
>            __len = __l2;
>        }
>        else
>        {
>            _ForwardIterator __mp1 = __m;
>            return pair<_ForwardIterator, _ForwardIterator>
>                   (
>                      __lower_bound<_Compare>(__first, __m, __value_, __comp),
>                      __upper_bound<_Compare>(++__mp1, __last, __value_, __comp)
>                   );
>        }
>    }
>    return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
>}
>
>template <class _ForwardIterator, class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<_ForwardIterator, _ForwardIterator>
>equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __equal_range<_Comp_ref>(__first, __last, __value_, __comp);
>
>}
>
>template <class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>pair<_ForwardIterator, _ForwardIterator>
>equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
>{
>    return std::__1::equal_range(__first, __last, __value_,
>                             __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
>}
>
>
>
>template <class _Compare, class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>    __first = __lower_bound<_Compare>(__first, __last, __value_, __comp);
>    return __first != __last && !__comp(__value_, *__first);
>}
>
>template <class _ForwardIterator, class _Tp, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __binary_search<_Comp_ref>(__first, __last, __value_, __comp);
>
>}
>
>template <class _ForwardIterator, class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
>{
>    return std::__1::binary_search(__first, __last, __value_,
>                             __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
>_OutputIterator
>__merge(_InputIterator1 __first1, _InputIterator1 __last1,
>        _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>    for (; __first1 != __last1; ++__result)
>    {
>        if (__first2 == __last2)
>            return std::__1::copy(__first1, __last1, __result);
>        if (__comp(*__first2, *__first1))
>        {
>            *__result = *__first2;
>            ++__first2;
>        }
>        else
>        {
>            *__result = *__first1;
>            ++__first1;
>        }
>    }
>    return std::__1::copy(__first2, __last2, __result);
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>merge(_InputIterator1 __first1, _InputIterator1 __last1,
>      _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return std::__1::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
>
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>merge(_InputIterator1 __first1, _InputIterator1 __last1,
>      _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
>{
>    typedef typename iterator_traits<_InputIterator1>::value_type __v1;
>    typedef typename iterator_traits<_InputIterator2>::value_type __v2;
>    return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
>}
>
>
>
>template <class _Compare, class _BidirectionalIterator>
>void
>__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
>                _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
>                                 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
>                typename iterator_traits<_BidirectionalIterator>::value_type* __buff)
>{
>    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
>    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
>    typedef typename iterator_traits<_BidirectionalIterator>::pointer pointer;
>    __destruct_n __d(0);
>    unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
>    if (__len1 <= __len2)
>    {
>        value_type* __p = __buff;
>        for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), ++__i, ++__p)
>            ::new(__p) value_type(std::__1::move(*__i));
>        __merge<_Compare>(move_iterator<value_type*>(__buff),
>                          move_iterator<value_type*>(__p),
>                          move_iterator<_BidirectionalIterator>(__middle),
>                          move_iterator<_BidirectionalIterator>(__last),
>                          __first, __comp);
>    }
>    else
>    {
>        value_type* __p = __buff;
>        for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), ++__i, ++__p)
>            ::new(__p) value_type(std::__1::move(*__i));
>        typedef reverse_iterator<_BidirectionalIterator> _RBi;
>        typedef reverse_iterator<value_type*> _Rv;
>        __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)),
>                move_iterator<_Rv>(_Rv(__p)), move_iterator<_Rv>(_Rv(__buff)),
>                _RBi(__last), __negate<_Compare>(__comp));
>    }
>}
>
>template <class _Compare, class _BidirectionalIterator>
>void
>__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
>                _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
>                                 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
>                typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size)
>{
>    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
>    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
>    while (true)
>    {
>
>        if (__len2 == 0)
>            return;
>
>        for (; true; ++__first, --__len1)
>        {
>            if (__len1 == 0)
>                return;
>            if (__comp(*__middle, *__first))
>                break;
>        }
>        if (__len1 <= __buff_size || __len2 <= __buff_size)
>        {
>            __buffered_inplace_merge<_Compare>(__first, __middle, __last, __comp, __len1, __len2, __buff);
>            return;
>        }
>        _BidirectionalIterator __m1;
>        _BidirectionalIterator __m2;
>        difference_type __len11;
>        difference_type __len21;
>
>        if (__len1 < __len2)
>        {
>            __len21 = __len2 / 2;
>            __m2 = __middle;
>            std::__1::advance(__m2, __len21);
>            __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp);
>            __len11 = std::__1::distance(__first, __m1);
>        }
>        else
>        {
>            if (__len1 == 1)
>            {
>
>                swap(*__first, *__middle);
>                return;
>            }
>
>            __len11 = __len1 / 2;
>            __m1 = __first;
>            std::__1::advance(__m1, __len11);
>            __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp);
>            __len21 = std::__1::distance(__middle, __m2);
>        }
>        difference_type __len12 = __len1 - __len11;
>        difference_type __len22 = __len2 - __len21;
>
>
>        __middle = std::__1::rotate(__m1, __middle, __m2);
>
>
>        if (__len11 + __len21 < __len12 + __len22)
>        {
>            __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
>
>            __first = __middle;
>            __middle = __m2;
>            __len1 = __len12;
>            __len2 = __len22;
>        }
>        else
>        {
>            __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
>
>            __last = __middle;
>            __middle = __m1;
>            __len1 = __len11;
>            __len2 = __len21;
>        }
>    }
>}
>
>template <class _Tp>
>struct __inplace_merge_switch
>{
>    static const unsigned value = is_trivially_copy_assignable<_Tp>::value;
>};
>
>template <class _BidirectionalIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
>              _Compare __comp)
>{
>    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
>    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
>    difference_type __len1 = std::__1::distance(__first, __middle);
>    difference_type __len2 = std::__1::distance(__middle, __last);
>    difference_type __buf_size = std::__1::min(__len1, __len2);
>    pair<value_type*, ptrdiff_t> __buf(0, 0);
>    unique_ptr<value_type, __return_temporary_buffer> __h;
>    if (__inplace_merge_switch<value_type>::value && __buf_size > 8)
>    {
>        __buf = std::__1::get_temporary_buffer<value_type>(__buf_size);
>        __h.reset(__buf.first);
>    }
>
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return std::__1::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
>                                            __buf.first, __buf.second);
>
>}
>
>template <class _BidirectionalIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)
>{
>    std::__1::inplace_merge(__first, __middle, __last,
>                        __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2>
>void
>__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
>        _InputIterator2 __first2, _InputIterator2 __last2,
>        typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp)
>{
>    typedef typename iterator_traits<_InputIterator1>::value_type value_type;
>    __destruct_n __d(0);
>    unique_ptr<value_type, __destruct_n&> __h(__result, __d);
>    for (; true; ++__result)
>    {
>        if (__first1 == __last1)
>        {
>            for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0))
>                ::new (__result) value_type(std::__1::move(*__first2));
>            __h.release();
>            return;
>        }
>        if (__first2 == __last2)
>        {
>            for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0))
>                ::new (__result) value_type(std::__1::move(*__first1));
>            __h.release();
>            return;
>        }
>        if (__comp(*__first2, *__first1))
>        {
>            ::new (__result) value_type(std::__1::move(*__first2));
>            __d.__incr((value_type*)0);
>            ++__first2;
>        }
>        else
>        {
>            ::new (__result) value_type(std::__1::move(*__first1));
>            __d.__incr((value_type*)0);
>            ++__first1;
>        }
>    }
>}
>
>template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
>void
>__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
>        _InputIterator2 __first2, _InputIterator2 __last2,
>        _OutputIterator __result, _Compare __comp)
>{
>    for (; __first1 != __last1; ++__result)
>    {
>        if (__first2 == __last2)
>        {
>            for (; __first1 != __last1; ++__first1, ++__result)
>                *__result = std::__1::move(*__first1);
>            return;
>        }
>        if (__comp(*__first2, *__first1))
>        {
>            *__result = std::__1::move(*__first2);
>            ++__first2;
>        }
>        else
>        {
>            *__result = std::__1::move(*__first1);
>            ++__first1;
>        }
>    }
>    for (; __first2 != __last2; ++__first2, ++__result)
>        *__result = std::__1::move(*__first2);
>}
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
>              typename iterator_traits<_RandomAccessIterator>::difference_type __len,
>              typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size);
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp,
>                   typename iterator_traits<_RandomAccessIterator>::difference_type __len,
>                   typename iterator_traits<_RandomAccessIterator>::value_type* __first2)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    switch (__len)
>    {
>    case 0:
>        return;
>    case 1:
>        ::new(__first2) value_type(std::__1::move(*__first1));
>        return;
>    case 2:
>       __destruct_n __d(0);
>        unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
>         if (__comp(*--__last1, *__first1))
>        {
>            ::new(__first2) value_type(std::__1::move(*__last1));
>            __d.__incr((value_type*)0);
>            ++__first2;
>            ::new(__first2) value_type(std::__1::move(*__first1));
>        }
>        else
>        {
>            ::new(__first2) value_type(std::__1::move(*__first1));
>            __d.__incr((value_type*)0);
>            ++__first2;
>            ::new(__first2) value_type(std::__1::move(*__last1));
>        }
>        __h2.release();
>        return;
>    }
>    if (__len <= 8)
>    {
>        __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp);
>        return;
>    }
>    typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
>    _RandomAccessIterator __m = __first1 + __l2;
>    __stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2);
>    __stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2);
>    __merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp);
>}
>
>template <class _Tp>
>struct __stable_sort_switch
>{
>    static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
>};
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
>              typename iterator_traits<_RandomAccessIterator>::difference_type __len,
>              typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    switch (__len)
>    {
>    case 0:
>    case 1:
>        return;
>    case 2:
>        if (__comp(*--__last, *__first))
>            swap(*__first, *__last);
>        return;
>    }
>    if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value))
>    {
>        __insertion_sort<_Compare>(__first, __last, __comp);
>        return;
>    }
>    typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
>    _RandomAccessIterator __m = __first + __l2;
>    if (__len <= __buff_size)
>    {
>        __destruct_n __d(0);
>        unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
>        __stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff);
>        __d.__set(__l2, (value_type*)0);
>        __stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2);
>        __d.__set(__len, (value_type*)0);
>        __merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp);
>
>
>
>
>
>        return;
>    }
>    __stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size);
>    __stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size);
>    __inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size);
>}
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    difference_type __len = __last - __first;
>    pair<value_type*, ptrdiff_t> __buf(0, 0);
>    unique_ptr<value_type, __return_temporary_buffer> __h;
>    if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value))
>    {
>        __buf = std::__1::get_temporary_buffer<value_type>(__len);
>        __h.reset(__buf.first);
>    }
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    std::__1::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _RandomAccessIterator, class _Compare>
>_RandomAccessIterator
>is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>    typedef typename std::__1::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    difference_type __len = __last - __first;
>    difference_type __p = 0;
>    difference_type __c = 1;
>    _RandomAccessIterator __pp = __first;
>    while (__c < __len)
>    {
>        _RandomAccessIterator __cp = __first + __c;
>        if (__comp(*__pp, *__cp))
>            return __cp;
>        ++__c;
>        ++__cp;
>        if (__c == __len)
>            return __last;
>        if (__comp(*__pp, *__cp))
>            return __cp;
>        ++__p;
>        ++__pp;
>        __c = 2 * __p + 1;
>    }
>    return __last;
>}
>
>template<class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_RandomAccessIterator
>is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    return std::__1::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>    return std::__1::is_heap_until(__first, __last, __comp) == __last;
>}
>
>template<class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    return std::__1::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__push_heap_front(_RandomAccessIterator __first, _RandomAccessIterator, _Compare __comp,
>                  typename iterator_traits<_RandomAccessIterator>::difference_type __len)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    if (__len > 1)
>    {
>        difference_type __p = 0;
>        _RandomAccessIterator __pp = __first;
>        difference_type __c = 2;
>        _RandomAccessIterator __cp = __first + __c;
>        if (__c == __len || __comp(*__cp, *(__cp - 1)))
>        {
>            --__c;
>            --__cp;
>        }
>        if (__comp(*__pp, *__cp))
>        {
>            value_type __t(std::__1::move(*__pp));
>            do
>            {
>                *__pp = std::__1::move(*__cp);
>                __pp = __cp;
>                __p = __c;
>                __c = (__p + 1) * 2;
>                if (__c > __len)
>                    break;
>                __cp = __first + __c;
>                if (__c == __len || __comp(*__cp, *(__cp - 1)))
>                {
>                    --__c;
>                    --__cp;
>                }
>            } while (__comp(__t, *__cp));
>            *__pp = std::__1::move(__t);
>        }
>    }
>}
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__push_heap_back(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
>                 typename iterator_traits<_RandomAccessIterator>::difference_type __len)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
>    if (__len > 1)
>    {
>        __len = (__len - 2) / 2;
>        _RandomAccessIterator __ptr = __first + __len;
>        if (__comp(*__ptr, *--__last))
>        {
>            value_type __t(std::__1::move(*__last));
>            do
>            {
>                *__last = std::__1::move(*__ptr);
>                __last = __ptr;
>                if (__len == 0)
>                    break;
>                __len = (__len - 1) / 2;
>                __ptr = __first + __len;
>            } while (__comp(*__ptr, __t));
>            *__last = std::__1::move(__t);
>        }
>    }
>}
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    std::__1::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
>           typename iterator_traits<_RandomAccessIterator>::difference_type __len)
>{
>    if (__len > 1)
>    {
>        swap(*__first, *--__last);
>        __push_heap_front<_Compare>(__first, __last, __comp, __len-1);
>    }
>}
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    std::__1::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    difference_type __n = __last - __first;
>    if (__n > 1)
>    {
>        __last = __first;
>        ++__last;
>        for (difference_type __i = 1; __i < __n;)
>            __push_heap_back<_Compare>(__first, ++__last, __comp, ++__i);
>    }
>}
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __make_heap<_Comp_ref>(__first, __last, __comp);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    std::__1::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    for (difference_type __n = __last - __first; __n > 1; --__last, --__n)
>        __pop_heap<_Compare>(__first, __last, __comp, __n);
>}
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __sort_heap<_Comp_ref>(__first, __last, __comp);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
>{
>    std::__1::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
>             _Compare __comp)
>{
>    __make_heap<_Compare>(__first, __middle, __comp);
>    typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first;
>    for (_RandomAccessIterator __i = __middle; __i != __last; ++__i)
>    {
>        if (__comp(*__i, *__first))
>        {
>            swap(*__i, *__first);
>            __push_heap_front<_Compare>(__first, __middle, __comp, __len);
>        }
>    }
>    __sort_heap<_Compare>(__first, __middle, __comp);
>}
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
>             _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
>{
>    std::__1::partial_sort(__first, __middle, __last,
>                       __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator, class _RandomAccessIterator>
>_RandomAccessIterator
>__partial_sort_copy(_InputIterator __first, _InputIterator __last,
>                    _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
>{
>    _RandomAccessIterator __r = __result_first;
>    if (__r != __result_last)
>    {
>        typename iterator_traits<_RandomAccessIterator>::difference_type __len = 0;
>        for (; __first != __last && __r != __result_last; ++__first, ++__r, ++__len)
>            *__r = *__first;
>        __make_heap<_Compare>(__result_first, __r, __comp);
>        for (; __first != __last; ++__first)
>            if (__comp(*__first, *__result_first))
>            {
>                *__result_first = *__first;
>                __push_heap_front<_Compare>(__result_first, __r, __comp, __len);
>            }
>        __sort_heap<_Compare>(__result_first, __r, __comp);
>    }
>    return __r;
>}
>
>template <class _InputIterator, class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_RandomAccessIterator
>partial_sort_copy(_InputIterator __first, _InputIterator __last,
>                  _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
>
>}
>
>template <class _InputIterator, class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_RandomAccessIterator
>partial_sort_copy(_InputIterator __first, _InputIterator __last,
>                  _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
>{
>    return std::__1::partial_sort_copy(__first, __last, __result_first, __result_last,
>                                   __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _RandomAccessIterator>
>void
>__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
>{
>
>    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
>    const difference_type __limit = 7;
>    while (true)
>    {
>    __restart:
>        if (__nth == __last)
>            return;
>        difference_type __len = __last - __first;
>        switch (__len)
>        {
>        case 0:
>        case 1:
>            return;
>        case 2:
>            if (__comp(*--__last, *__first))
>                swap(*__first, *__last);
>            return;
>        case 3:
>            {
>            _RandomAccessIterator __m = __first;
>            std::__1::__sort3<_Compare>(__first, ++__m, --__last, __comp);
>            return;
>            }
>        }
>        if (__len <= __limit)
>        {
>            __selection_sort<_Compare>(__first, __last, __comp);
>            return;
>        }
>
>        _RandomAccessIterator __m = __first + __len/2;
>        _RandomAccessIterator __lm1 = __last;
>        unsigned __n_swaps = std::__1::__sort3<_Compare>(__first, __m, --__lm1, __comp);
>
>
>
>        _RandomAccessIterator __i = __first;
>        _RandomAccessIterator __j = __lm1;
>
>
>
>        if (!__comp(*__i, *__m))
>        {
>
>
>            while (true)
>            {
>                if (__i == --__j)
>                {
>
>
>                    ++__i;
>                    __j = __last;
>                    if (!__comp(*__first, *--__j))
>                    {
>                        while (true)
>                        {
>                            if (__i == __j)
>                                return;
>                            if (__comp(*__first, *__i))
>                            {
>                                swap(*__i, *__j);
>                                ++__n_swaps;
>                                ++__i;
>                                break;
>                            }
>                            ++__i;
>                        }
>                    }
>
>                    if (__i == __j)
>                        return;
>                    while (true)
>                    {
>                        while (!__comp(*__first, *__i))
>                            ++__i;
>                        while (__comp(*__first, *--__j))
>                            ;
>                        if (__i >= __j)
>                            break;
>                        swap(*__i, *__j);
>                        ++__n_swaps;
>                        ++__i;
>                    }
>
>
>                    if (__nth < __i)
>                        return;
>
>
>                    __first = __i;
>                    goto __restart;
>                }
>                if (__comp(*__j, *__m))
>                {
>                    swap(*__i, *__j);
>                    ++__n_swaps;
>                    break;
>                }
>            }
>        }
>        ++__i;
>
>
>        if (__i < __j)
>        {
>
>            while (true)
>            {
>
>                while (__comp(*__i, *__m))
>                    ++__i;
>
>                while (!__comp(*--__j, *__m))
>                    ;
>                if (__i >= __j)
>                    break;
>                swap(*__i, *__j);
>                ++__n_swaps;
>
>
>                if (__m == __i)
>                    __m = __j;
>                ++__i;
>            }
>        }
>
>        if (__i != __m && __comp(*__m, *__i))
>        {
>            swap(*__i, *__m);
>            ++__n_swaps;
>        }
>
>        if (__nth == __i)
>            return;
>        if (__n_swaps == 0)
>        {
>
>            if (__nth < __i)
>            {
>
>                __j = __m = __first;
>                while (++__j != __i)
>                {
>                    if (__comp(*__j, *__m))
>
>                        goto not_sorted;
>                    __m = __j;
>                }
>
>                return;
>            }
>            else
>            {
>
>                __j = __m = __i;
>                while (++__j != __last)
>                {
>                    if (__comp(*__j, *__m))
>
>                        goto not_sorted;
>                    __m = __j;
>                }
>
>                return;
>            }
>        }
>not_sorted:
>
>        if (__nth < __i)
>        {
>
>            __last = __i;
>        }
>        else
>        {
>
>            __first = ++__i;
>        }
>    }
>}
>
>template <class _RandomAccessIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    __nth_element<_Comp_ref>(__first, __nth, __last, __comp);
>
>}
>
>template <class _RandomAccessIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)
>{
>    std::__1::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2>
>bool
>__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
>           _Compare __comp)
>{
>    for (; __first2 != __last2; ++__first1)
>    {
>        if (__first1 == __last1 || __comp(*__first2, *__first1))
>            return false;
>        if (!__comp(*__first1, *__first2))
>            ++__first2;
>    }
>    return true;
>}
>
>template <class _InputIterator1, class _InputIterator2, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
>         _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
>
>}
>
>template <class _InputIterator1, class _InputIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)
>{
>    return std::__1::includes(__first1, __last1, __first2, __last2,
>                          __less<typename iterator_traits<_InputIterator1>::value_type,
>                                 typename iterator_traits<_InputIterator2>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
>_OutputIterator
>__set_union(_InputIterator1 __first1, _InputIterator1 __last1,
>            _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>    for (; __first1 != __last1; ++__result)
>    {
>        if (__first2 == __last2)
>            return std::__1::copy(__first1, __last1, __result);
>        if (__comp(*__first2, *__first1))
>        {
>            *__result = *__first2;
>            ++__first2;
>        }
>        else
>        {
>            *__result = *__first1;
>            if (!__comp(*__first1, *__first2))
>                ++__first2;
>            ++__first1;
>        }
>    }
>    return std::__1::copy(__first2, __last2, __result);
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_union(_InputIterator1 __first1, _InputIterator1 __last1,
>          _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
>
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_union(_InputIterator1 __first1, _InputIterator1 __last1,
>          _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
>{
>    return std::__1::set_union(__first1, __last1, __first2, __last2, __result,
>                          __less<typename iterator_traits<_InputIterator1>::value_type,
>                                 typename iterator_traits<_InputIterator2>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
>_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))
>            {
>                *__result = *__first1;
>                ++__result;
>                ++__first1;
>            }
>            ++__first2;
>        }
>    }
>    return __result;
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
>                 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
>
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
>                 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
>{
>    return std::__1::set_intersection(__first1, __last1, __first2, __last2, __result,
>                                  __less<typename iterator_traits<_InputIterator1>::value_type,
>                                         typename iterator_traits<_InputIterator2>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
>_OutputIterator
>__set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>                 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>    while (__first1 != __last1)
>    {
>        if (__first2 == __last2)
>            return std::__1::copy(__first1, __last1, __result);
>        if (__comp(*__first1, *__first2))
>        {
>            *__result = *__first1;
>            ++__result;
>            ++__first1;
>        }
>        else
>        {
>            if (!__comp(*__first2, *__first1))
>                ++__first1;
>            ++__first2;
>        }
>    }
>    return __result;
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>               _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
>
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>               _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
>{
>    return std::__1::set_difference(__first1, __last1, __first2, __last2, __result,
>                                __less<typename iterator_traits<_InputIterator1>::value_type,
>                                       typename iterator_traits<_InputIterator2>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
>_OutputIterator
>__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>                           _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>    while (__first1 != __last1)
>    {
>        if (__first2 == __last2)
>            return std::__1::copy(__first1, __last1, __result);
>        if (__comp(*__first1, *__first2))
>        {
>            *__result = *__first1;
>            ++__result;
>            ++__first1;
>        }
>        else
>        {
>            if (__comp(*__first2, *__first1))
>            {
>                *__result = *__first2;
>                ++__result;
>            }
>            else
>                ++__first1;
>            ++__first2;
>        }
>    }
>    return std::__1::copy(__first2, __last2, __result);
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>                         _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
>
>}
>
>template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_OutputIterator
>set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
>                         _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
>{
>    return std::__1::set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
>                                          __less<typename iterator_traits<_InputIterator1>::value_type,
>                                                 typename iterator_traits<_InputIterator2>::value_type>());
>}
>
>
>
>template <class _Compare, class _InputIterator1, class _InputIterator2>
>bool
>__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
>                          _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
>{
>    for (; __first2 != __last2; ++__first1, ++__first2)
>    {
>        if (__first1 == __last1 || __comp(*__first1, *__first2))
>            return true;
>        if (__comp(*__first2, *__first1))
>            return false;
>    }
>    return false;
>}
>
>template <class _InputIterator1, class _InputIterator2, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
>                        _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
>
>}
>
>template <class _InputIterator1, class _InputIterator2>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
>                        _InputIterator2 __first2, _InputIterator2 __last2)
>{
>    return std::__1::lexicographical_compare(__first1, __last1, __first2, __last2,
>                                         __less<typename iterator_traits<_InputIterator1>::value_type,
>                                                typename iterator_traits<_InputIterator2>::value_type>());
>}
>
>
>
>template <class _Compare, class _BidirectionalIterator>
>bool
>__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
>{
>    _BidirectionalIterator __i = __last;
>    if (__first == __last || __first == --__i)
>        return false;
>    while (true)
>    {
>        _BidirectionalIterator __ip1 = __i;
>        if (__comp(*--__i, *__ip1))
>        {
>            _BidirectionalIterator __j = __last;
>            while (!__comp(*__i, *--__j))
>                ;
>            swap(*__i, *__j);
>            std::__1::reverse(__ip1, __last);
>            return true;
>        }
>        if (__i == __first)
>        {
>            std::__1::reverse(__first, __last);
>            return false;
>        }
>    }
>}
>
>template <class _BidirectionalIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __next_permutation<_Comp_ref>(__first, __last, __comp);
>
>}
>
>template <class _BidirectionalIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
>{
>    return std::__1::next_permutation(__first, __last,
>                                  __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
>}
>
>
>
>template <class _Compare, class _BidirectionalIterator>
>bool
>__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
>{
>    _BidirectionalIterator __i = __last;
>    if (__first == __last || __first == --__i)
>        return false;
>    while (true)
>    {
>        _BidirectionalIterator __ip1 = __i;
>        if (__comp(*__ip1, *--__i))
>        {
>            _BidirectionalIterator __j = __last;
>            while (!__comp(*--__j, *__i))
>                ;
>            swap(*__i, *__j);
>            std::__1::reverse(__ip1, __last);
>            return true;
>        }
>        if (__i == __first)
>        {
>            std::__1::reverse(__first, __last);
>            return false;
>        }
>    }
>}
>
>template <class _BidirectionalIterator, class _Compare>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
>{
>
>
>
>
>
>    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
>    return __prev_permutation<_Comp_ref>(__first, __last, __comp);
>
>}
>
>template <class _BidirectionalIterator>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>bool
>prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
>{
>    return std::__1::prev_permutation(__first, __last,
>                                  __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_integral<_Tp>::value,
>    _Tp
>>::type
>__rotate_left(_Tp __t, _Tp __n = 1)
>{
>    const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * 8 - 1);
>    __n &= __bits;
>    return static_cast<_Tp>((__t << __n) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> (__bits - __n)));
>}
>
>template <class _Tp>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename enable_if
><
>    is_integral<_Tp>::value,
>    _Tp
>>::type
>__rotate_right(_Tp __t, _Tp __n = 1)
>{
>    const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * 8 - 1);
>    __n &= __bits;
>    return static_cast<_Tp>((__t << (__bits - __n)) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> __n));
>}
>
>} }
>
>       
>
>
>namespace std { namespace __1 {
>
>template <class _Tp, class _VoidPtr> struct __list_node;
>
>template <class _Tp, class _VoidPtr>
>struct __list_node_base
>{
>    typedef typename pointer_traits<_VoidPtr>::template
>
>
>
>        rebind<__list_node<_Tp, _VoidPtr> >::other pointer;
>
>
>    typedef typename pointer_traits<_VoidPtr>::template
>
>
>
>        rebind<__list_node_base>::other __base_pointer;
>
>
>    pointer __prev_;
>    pointer __next_;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_node_base()
>        : __prev_(static_cast<pointer>(pointer_traits<__base_pointer>::pointer_to(*this))),
>          __next_(static_cast<pointer>(pointer_traits<__base_pointer>::pointer_to(*this)))
>          {}
>};
>
>template <class _Tp, class _VoidPtr>
>struct __list_node
>    : public __list_node_base<_Tp, _VoidPtr>
>{
>    _Tp __value_;
>};
>
>template <class _Tp, class _Alloc> class __attribute__ ((__visibility__("default"))) list;
>template <class _Tp, class _Alloc> class __list_imp;
>template <class _Tp, class _VoidPtr> class __attribute__ ((__visibility__("default"))) __list_const_iterator;
>
>template <class _Tp, class _VoidPtr>
>class __attribute__ ((__visibility__("default"))) __list_iterator
>{
>    typedef typename pointer_traits<_VoidPtr>::template
>
>
>
>        rebind<__list_node<_Tp, _VoidPtr> >::other __node_pointer;
>
>
>    __node_pointer __ptr_;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit __list_iterator(__node_pointer __p) throw() : __ptr_(__p) {}
>
>    template<class, class> friend class list;
>    template<class, class> friend class __list_imp;
>    template<class, class> friend class __list_const_iterator;
>public:
>    typedef bidirectional_iterator_tag iterator_category;
>    typedef _Tp value_type;
>    typedef value_type& reference;
>    typedef typename pointer_traits<_VoidPtr>::template
>
>            rebind<value_type>::other pointer;
>    typedef typename pointer_traits<pointer>::difference_type difference_type;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_iterator() throw() : __ptr_(nullptr)
>    {
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    reference operator*() const
>    {
>
>
>
>
>        return __ptr_->__value_;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pointer operator->() const
>    {
>
>
>
>
>        return pointer_traits<pointer>::pointer_to(__ptr_->__value_);
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_iterator& operator++()
>    {
>        __ptr_ = __ptr_->__next_;
>        return *this;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_iterator operator++(int) {__list_iterator __t(*this); ++(*this); return __t;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_iterator& operator--()
>    {
>
>
>
>
>        __ptr_ = __ptr_->__prev_;
>        return *this;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_iterator operator--(int) {__list_iterator __t(*this); --(*this); return __t;}
>
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator==(const __list_iterator& __x, const __list_iterator& __y)
>    {
>        return __x.__ptr_ == __y.__ptr_;
>    }
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>     bool operator!=(const __list_iterator& __x, const __list_iterator& __y)
>        {return !(__x == __y);}
>};
>
>template <class _Tp, class _VoidPtr>
>class __attribute__ ((__visibility__("default"))) __list_const_iterator
>{
>    typedef typename pointer_traits<_VoidPtr>::template
>
>
>
>        rebind<__list_node<_Tp, _VoidPtr> >::other __node_pointer;
>
>
>    __node_pointer __ptr_;
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit __list_const_iterator(__node_pointer __p) throw() : __ptr_(__p) {}
>
>
>    template<class, class> friend class list;
>    template<class, class> friend class __list_imp;
>public:
>    typedef bidirectional_iterator_tag iterator_category;
>    typedef _Tp value_type;
>    typedef const value_type& reference;
>    typedef typename pointer_traits<_VoidPtr>::template
>
>
>
>            rebind<const value_type>::other
>
>                                             pointer;
>    typedef typename pointer_traits<pointer>::difference_type difference_type;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_const_iterator() throw() : __ptr_(nullptr)
>    {
>
>
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) throw()
>        : __ptr_(__p.__ptr_)
>    {
>
>
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    reference operator*() const
>    {
>
>
>
>
>        return __ptr_->__value_;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    pointer operator->() const
>    {
>
>
>
>
>        return pointer_traits<pointer>::pointer_to(__ptr_->__value_);
>    }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_const_iterator& operator++()
>    {
>
>
>
>
>        __ptr_ = __ptr_->__next_;
>        return *this;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_const_iterator operator++(int) {__list_const_iterator __t(*this); ++(*this); return __t;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_const_iterator& operator--()
>    {
>
>
>
>
>        __ptr_ = __ptr_->__prev_;
>        return *this;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    __list_const_iterator operator--(int) {__list_const_iterator __t(*this); --(*this); return __t;}
>
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y)
>    {
>        return __x.__ptr_ == __y.__ptr_;
>    }
>    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y)
>        {return !(__x == __y);}
>};
>
>template <class _Tp, class _Alloc>
>class __list_imp
>{
>    __list_imp(const __list_imp&);
>    __list_imp& operator=(const __list_imp&);
>protected:
>    typedef _Tp value_type;
>    typedef _Alloc allocator_type;
>    typedef allocator_traits<allocator_type> __alloc_traits;
>    typedef typename __alloc_traits::size_type size_type;
>    typedef typename __alloc_traits::void_pointer __void_pointer;
>    typedef __list_iterator<value_type, __void_pointer> iterator;
>    typedef __list_const_iterator<value_type, __void_pointer> const_iterator;
>    typedef __list_node_base<value_type, __void_pointer> __node_base;
>    typedef __list_node<value_type, __void_pointer> __node;
>    typedef typename __alloc_traits::template
>
>
>
>                rebind_alloc<__node>::other
>
>                                                                     __node_allocator;
>    typedef allocator_traits<__node_allocator> __node_alloc_traits;
>    typedef typename __node_alloc_traits::pointer __node_pointer;
>    typedef typename __node_alloc_traits::pointer __node_const_pointer;
>    typedef typename __alloc_traits::pointer pointer;
>    typedef typename __alloc_traits::const_pointer const_pointer;
>    typedef typename __alloc_traits::difference_type difference_type;
>
>    typedef typename __alloc_traits::template
>
>
>
>                rebind_alloc<__node_base>::other
>
>                                                                     __node_base_allocator;
>    typedef typename allocator_traits<__node_base_allocator>::pointer __node_base_pointer;
>
>    __node_base __end_;
>    __compressed_pair<size_type, __node_allocator> __size_alloc_;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>          size_type& __sz() throw() {return __size_alloc_.first();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const size_type& __sz() const throw()
>        {return __size_alloc_.first();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>          __node_allocator& __node_alloc() throw()
>          {return __size_alloc_.second();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const __node_allocator& __node_alloc() const throw()
>        {return __size_alloc_.second();}
>
>    static void __unlink_nodes(__node_pointer __f, __node_pointer __l) throw();
>
>    __list_imp()
>        ;
>    __list_imp(const allocator_type& __a);
>    ~__list_imp();
>    void clear() throw();
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool empty() const throw() {return __sz() == 0;}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    iterator begin() throw()
>    {
>
>
>
>        return iterator(__end_.__next_);
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_iterator begin() const throw()
>    {
>
>
>
>        return const_iterator(__end_.__next_);
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    iterator end() throw()
>    {
>
>
>
>
>        return iterator(static_cast<__node_pointer>(
>                      pointer_traits<__node_base_pointer>::pointer_to(__end_)));
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_iterator end() const throw()
>    {
>
>
>
>
>        return const_iterator(static_cast<__node_const_pointer>(
>        pointer_traits<__node_base_pointer>::pointer_to(const_cast<__node_base&>(__end_))));
>
>    }
>
>    void swap(__list_imp& __c)
>       
>                                                                   ;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void __copy_assign_alloc(const __list_imp& __c)
>        {__copy_assign_alloc(__c, integral_constant<bool,
>                      __node_alloc_traits::propagate_on_container_copy_assignment::value>());}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void __move_assign_alloc(__list_imp& __c)
>       
>
>
>        {__move_assign_alloc(__c, integral_constant<bool,
>                      __node_alloc_traits::propagate_on_container_move_assignment::value>());}
>
>private:
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
>       
>
>        {__swap_alloc(__x, __y, integral_constant<bool,
>                      __node_alloc_traits::propagate_on_container_swap::value>());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
>       
>        {
>            using std::__1::swap;
>            swap(__x, __y);
>        }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, false_type)
>        throw()
>        {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void __copy_assign_alloc(const __list_imp& __c, true_type)
>        {
>            if (__node_alloc() != __c.__node_alloc())
>                clear();
>            __node_alloc() = __c.__node_alloc();
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void __copy_assign_alloc(const __list_imp& __c, false_type)
>        {}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void __move_assign_alloc(__list_imp& __c, true_type)
>       
>        {
>            __node_alloc() = std::__1::move(__c.__node_alloc());
>        }
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void __move_assign_alloc(__list_imp& __c, false_type)
>        throw()
>        {}
>};
>
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>__list_imp<_Tp, _Alloc>::__unlink_nodes(__node_pointer __f, __node_pointer __l)
>    throw()
>{
>    __f->__prev_->__next_ = __l->__next_;
>    __l->__next_->__prev_ = __f->__prev_;
>}
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>__list_imp<_Tp, _Alloc>::__list_imp()
>       
>    : __size_alloc_(0)
>{
>}
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>__list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a)
>    : __size_alloc_(0, __node_allocator(__a))
>{
>}
>
>template <class _Tp, class _Alloc>
>__list_imp<_Tp, _Alloc>::~__list_imp()
>{
>    clear();
>
>
>
>}
>
>template <class _Tp, class _Alloc>
>void
>__list_imp<_Tp, _Alloc>::clear() throw()
>{
>    if (!empty())
>    {
>        __node_allocator& __na = __node_alloc();
>        __node_pointer __f = __end_.__next_;
>        __node_pointer __l = static_cast<__node_pointer>(
>                       pointer_traits<__node_base_pointer>::pointer_to(__end_));
>        __unlink_nodes(__f, __l->__prev_);
>        __sz() = 0;
>        while (__f != __l)
>        {
>            __node_pointer __n = __f;
>            __f = __f->__next_;
>            __node_alloc_traits::destroy(__na, std::__1::addressof(__n->__value_));
>            __node_alloc_traits::deallocate(__na, __n, 1);
>        }
>    }
>}
>
>template <class _Tp, class _Alloc>
>void
>__list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
>       
>
>{
>    ((void)0)
>
>
>                                                           ;
>    using std::__1::swap;
>    __swap_alloc(__node_alloc(), __c.__node_alloc());
>    swap(__sz(), __c.__sz());
>    swap(__end_, __c.__end_);
>    if (__sz() == 0)
>        __end_.__next_ = __end_.__prev_ = static_cast<__node_pointer>(
>                       pointer_traits<__node_base_pointer>::pointer_to(__end_));
>    else
>        __end_.__prev_->__next_ = __end_.__next_->__prev_
>                                = static_cast<__node_pointer>(
>                       pointer_traits<__node_base_pointer>::pointer_to(__end_));
>    if (__c.__sz() == 0)
>        __c.__end_.__next_ = __c.__end_.__prev_
>                           = static_cast<__node_pointer>(
>                       pointer_traits<__node_base_pointer>::pointer_to(__c.__end_));
>    else
>        __c.__end_.__prev_->__next_ = __c.__end_.__next_->__prev_
>                                    = static_cast<__node_pointer>(
>                       pointer_traits<__node_base_pointer>::pointer_to(__c.__end_));
>}
>
>template <class _Tp, class _Alloc = allocator<_Tp> >
>class __attribute__ ((__visibility__("default"))) list
>    : private __list_imp<_Tp, _Alloc>
>{
>    typedef __list_imp<_Tp, _Alloc> base;
>    typedef typename base::__node __node;
>    typedef typename base::__node_allocator __node_allocator;
>    typedef typename base::__node_pointer __node_pointer;
>    typedef typename base::__node_alloc_traits __node_alloc_traits;
>    typedef typename base::__node_base __node_base;
>    typedef typename base::__node_base_pointer __node_base_pointer;
>
>public:
>    typedef _Tp value_type;
>    typedef _Alloc allocator_type;
>    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
>                  "Invalid allocator::value_type");
>    typedef value_type& reference;
>    typedef const value_type& const_reference;
>    typedef typename base::pointer pointer;
>    typedef typename base::const_pointer const_pointer;
>    typedef typename base::size_type size_type;
>    typedef typename base::difference_type difference_type;
>    typedef typename base::iterator iterator;
>    typedef typename base::const_iterator const_iterator;
>    typedef std::__1::reverse_iterator<iterator> reverse_iterator;
>    typedef std::__1::reverse_iterator<const_iterator> const_reverse_iterator;
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    list()
>       
>    {
>
>
>
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    explicit list(const allocator_type& __a) : base(__a)
>    {
>
>
>
>    }
>    explicit list(size_type __n);
>
>
>
>    list(size_type __n, const value_type& __x);
>    list(size_type __n, const value_type& __x, const allocator_type& __a);
>    template <class _InpIter>
>        list(_InpIter __f, _InpIter __l,
>             typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
>    template <class _InpIter>
>        list(_InpIter __f, _InpIter __l, const allocator_type& __a,
>             typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
>
>    list(const list& __c);
>    list(const list& __c, const allocator_type& __a);
>    list& operator=(const list& __c);
>
>    list(initializer_list<value_type> __il);
>    list(initializer_list<value_type> __il, const allocator_type& __a);
>
>
>    list(list&& __c)
>        ;
>    list(list&& __c, const allocator_type& __a);
>    list& operator=(list&& __c)
>       
>
>                                                                ;
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    list& operator=(initializer_list<value_type> __il)
>        {assign(__il.begin(), __il.end()); return *this;}
>
>
>    template <class _InpIter>
>        void assign(_InpIter __f, _InpIter __l,
>             typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
>    void assign(size_type __n, const value_type& __x);
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void assign(initializer_list<value_type> __il)
>        {assign(__il.begin(), __il.end());}
>
>
>    allocator_type get_allocator() const throw();
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_type size() const throw() {return base::__sz();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    bool empty() const throw() {return base::empty();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    size_type max_size() const throw()
>        {return numeric_limits<difference_type>::max();}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>          iterator begin() throw() {return base::begin();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_iterator begin() const throw() {return base::begin();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>          iterator end() throw() {return base::end();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_iterator end() const throw() {return base::end();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_iterator cbegin() const throw() {return base::begin();}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_iterator cend() const throw() {return base::end();}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>          reverse_iterator rbegin() throw()
>            {return reverse_iterator(end());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_reverse_iterator rbegin() const throw()
>        {return const_reverse_iterator(end());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>          reverse_iterator rend() throw()
>            {return reverse_iterator(begin());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_reverse_iterator rend() const throw()
>        {return const_reverse_iterator(begin());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_reverse_iterator crbegin() const throw()
>        {return const_reverse_iterator(end());}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_reverse_iterator crend() const throw()
>        {return const_reverse_iterator(begin());}
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    reference front()
>    {
>        ((void)0);
>        return base::__end_.__next_->__value_;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_reference front() const
>    {
>        ((void)0);
>        return base::__end_.__next_->__value_;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    reference back()
>    {
>        ((void)0);
>        return base::__end_.__prev_->__value_;
>    }
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    const_reference back() const
>    {
>        ((void)0);
>        return base::__end_.__prev_->__value_;
>    }
>
>
>    void push_front(value_type&& __x);
>    void push_back(value_type&& __x);
>
>    template <class... _Args>
>       void emplace_front(_Args&&... __args);
>    template <class... _Args>
>        void emplace_back(_Args&&... __args);
>    template <class... _Args>
>        iterator emplace(const_iterator __p, _Args&&... __args);
>
>    iterator insert(const_iterator __p, value_type&& __x);
>
>
>    void push_front(const value_type& __x);
>    void push_back(const value_type& __x);
>
>    iterator insert(const_iterator __p, const value_type& __x);
>    iterator insert(const_iterator __p, size_type __n, const value_type& __x);
>    template <class _InpIter>
>        iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
>             typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    iterator insert(const_iterator __p, initializer_list<value_type> __il)
>        {return insert(__p, __il.begin(), __il.end());}
>
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void swap(list& __c)
>       
>
>        {base::swap(__c);}
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void clear() throw() {base::clear();}
>
>    void pop_front();
>    void pop_back();
>
>    iterator erase(const_iterator __p);
>    iterator erase(const_iterator __f, const_iterator __l);
>
>    void resize(size_type __n);
>    void resize(size_type __n, const value_type& __x);
>
>    void splice(const_iterator __p, list& __c);
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void splice(const_iterator __p, list&& __c) {splice(__p, __c);}
>
>    void splice(const_iterator __p, list& __c, const_iterator __i);
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void splice(const_iterator __p, list&& __c, const_iterator __i)
>        {splice(__p, __c, __i);}
>
>    void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l);
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l)
>        {splice(__p, __c, __f, __l);}
>
>
>    void remove(const value_type& __x);
>    template <class _Pred> void remove_if(_Pred __pred);
>    void unique();
>    template <class _BinaryPred>
>        void unique(_BinaryPred __binary_pred);
>    void merge(list& __c);
>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>    void merge(list&& __c) {merge(__c);}
>
>    template <class _Comp>
>        void merge(list& __c, _Comp __comp);
>
>    template <class _Comp>
>    __attribute__ ((__visibility__("hidden"), __always_inline__))
>        void merge(list&& __c, _Comp __comp) {merge(__c, __comp);}
>
>    void sort();
>    template <class _Comp>
>        void sort(_Comp __comp);
>
>    void reverse() throw();
>
>    bool __invariants() const;
>private:
>    static void __link_nodes(__node_pointer __p, __node_pointer __f, __node_pointer __l);
>    iterator __iterator(size_type __n);
>    template <class _Comp>
>        static iterator __sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp);
>
>    void __move_assign(list& __c, true_type)
>        ;
>    void __move_assign(list& __c, false_type);
>};
>
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>list<_Tp, _Alloc>::__link_nodes(__node_pointer __p, __node_pointer __f, __node_pointer __l)
>{
>    __p->__prev_->__next_ = __f;
>    __f->__prev_ = __p->__prev_;
>    __p->__prev_ = __l;
>    __l->__next_ = __p;
>}
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>typename list<_Tp, _Alloc>::iterator
>list<_Tp, _Alloc>::__iterator(size_type __n)
>{
>    return __n <= base::__sz() / 2 ? std::__1::next(begin(), __n)
>                                   : std::__1::prev(end(), base::__sz() - __n);
>}
>
>template <class _Tp, class _Alloc>
>list<_Tp, _Alloc>::list(size_type __n)
>{
>
>
>
>    for (; __n > 0; --__n)
>
>        emplace_back();
>
>
>
>}
>template <class _Tp, class _Alloc>
>list<_Tp, _Alloc>::list(size_type __n, const value_type& __x)
>{
>
>
>
>    for (; __n > 0; --__n)
>        push_back(__x);
>}
>
>template <class _Tp, class _Alloc>
>list<_Tp, _Alloc>::list(size_type __n, const value_type& __x, const allocator_type& __a)
>    : base(__a)
>{
>
>
>
>    for (; __n > 0; --__n)
>        push_back(__x);
>}
>
>template <class _Tp, class _Alloc>
>template <class _InpIter>
>list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,
>                        typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
>{
>
>
>
>    for (; __f != __l; ++__f)
>        push_back(*__f);
>}
>
>template <class _Tp, class _Alloc>
>template <class _InpIter>
>list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a,
>                        typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
>    : base(__a)
>{
>
>
>
>    for (; __f != __l; ++__f)
>        push_back(*__f);
>}
>
>template <class _Tp, class _Alloc>
>list<_Tp, _Alloc>::list(const list& __c)
>    : base(allocator_type(
>           __node_alloc_traits::select_on_container_copy_construction(
>                __c.__node_alloc())))
>{
>
>
>
>    for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
>        push_back(*__i);
>}
>
>template <class _Tp, class _Alloc>
>list<_Tp, _Alloc>::list(const list& __c, const allocator_type& __a)
>    : base(__a)
>{
>
>
>
>    for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
>        push_back(*__i);
>}
>
>
>
>template <class _Tp, class _Alloc>
>list<_Tp, _Alloc>::list(initializer_list<value_type> __il, const allocator_type& __a)
>    : base(__a)
>{
>
>
>
>    for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
>            __e = __il.end(); __i != __e; ++__i)
>        push_back(*__i);
>}
>
>template <class _Tp, class _Alloc>
>list<_Tp, _Alloc>::list(initializer_list<value_type> __il)
>{
>
>
>
>    for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
>            __e = __il.end(); __i != __e; ++__i)
>        push_back(*__i);
>}
>
>
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>list<_Tp, _Alloc>&
>list<_Tp, _Alloc>::operator=(const list& __c)
>{
>    if (this != &__c)
>    {
>        base::__copy_assign_alloc(__c);
>        assign(__c.begin(), __c.end());
>    }
>    return *this;
>}
>
>
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>list<_Tp, _Alloc>::list(list&& __c)
>   
>    : base(allocator_type(std::__1::move(__c.__node_alloc())))
>{
>
>
>
>    splice(end(), __c);
>}
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a)
>    : base(__a)
>{
>
>
>
>    if (__a == __c.get_allocator())
>        splice(end(), __c);
>    else
>    {
>        typedef move_iterator<iterator> _Ip;
>        assign(_Ip(__c.begin()), _Ip(__c.end()));
>    }
>}
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>list<_Tp, _Alloc>&
>list<_Tp, _Alloc>::operator=(list&& __c)
>       
>
>
>{
>    __move_assign(__c, integral_constant<bool,
>          __node_alloc_traits::propagate_on_container_move_assignment::value>());
>    return *this;
>}
>
>template <class _Tp, class _Alloc>
>void
>list<_Tp, _Alloc>::__move_assign(list& __c, false_type)
>{
>    if (base::__node_alloc() != __c.__node_alloc())
>    {
>        typedef move_iterator<iterator> _Ip;
>        assign(_Ip(__c.begin()), _Ip(__c.end()));
>    }
>    else
>        __move_assign(__c, true_type());
>}
>
>template <class _Tp, class _Alloc>
>void
>list<_Tp, _Alloc>::__move_assign(list& __c, true_type)
>       
>{
>    clear();
>    base::__move_assign_alloc(__c);
>    splice(end(), __c);
>}
>
>
>
>template <class _Tp, class _Alloc>
>template <class _InpIter>
>void
>list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l,
>                          typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
>{
>    iterator __i = begin();
>    iterator __e = end();
>    for (; __f != __l && __i != __e; ++__f, ++__i)
>        *__i = *__f;
>    if (__i == __e)
>        insert(__e, __f, __l);
>    else
>        erase(__i, __e);
>}
>
>template <class _Tp, class _Alloc>
>void
>list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x)
>{
>    iterator __i = begin();
>    iterator __e = end();
>    for (; __n > 0 && __i != __e; --__n, ++__i)
>        *__i = __x;
>    if (__i == __e)
>        insert(__e, __n, __x);
>    else
>        erase(__i, __e);
>}
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>_Alloc
>list<_Tp, _Alloc>::get_allocator() const throw()
>{
>    return allocator_type(base::__node_alloc());
>}
>
>template <class _Tp, class _Alloc>
>void
>list<_Tp, _Alloc>::push_back(const value_type& __x)
>{
>    __node_allocator& __na = base::__node_alloc();
>    typedef __allocator_destructor<__node_allocator> _Dp;
>    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
>    __node_alloc_traits::construct(__na, std::__1::addressof(__hold->__value_), __x);
>    __link_nodes(static_cast<__node_pointer>(pointer_traits<__node_base_pointer>::
>                         pointer_to(base::__end_)), __hold.get(), __hold.get());
>    ++base::__sz();
>    __hold.release();
>}
>
>
>template <class _Tp, class _Alloc>
>__attribute__((always_inline)) void
>list<_Tp, _Alloc>::splice(const_iterator __p, list& __c)
>{
>    ((void)0);
>
>    if (!__c.empty())
>    {
>        __node_pointer __f = __c.__end_.__next_;
>        __node_pointer __l = __c.__end_.__prev_;
>        base::__unlink_nodes(__f, __l);
>        __link_nodes(__p.__ptr_, __f, __l);
>        base::__sz() += __c.__sz();
>        __c.__sz() = 0;
>    }
>}
>
>template <class _Tp, class _Alloc>
>void
>list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i)
>{
>    if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_)
>    {
>        __node_pointer __f = __i.__ptr_;
>        base::__unlink_nodes(__f, __f);
>        __link_nodes(__p.__ptr_, __f, __f);
>        --__c.__sz();
>        ++base::__sz();
>    }
>}
>
>template <class _Tp, class _Alloc>
>void
>list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l)
>{
>    if (__f != __l)
>    {
>        if (this != &__c)
>        {
>            size_type __s = std::__1::distance(__f, __l);
>            __c.__sz() -= __s;
>            base::__sz() += __s;
>        }
>        __node_pointer __first = __f.__ptr_;
>        --__l;
>        __node_pointer __last = __l.__ptr_;
>        base::__unlink_nodes(__first, __last);
>        __link_nodes(__p.__ptr_, __first, __last);
>    }
>}
>
>
>template <class _Tp, class _Alloc>
>inline __attribute__ ((__visibility__("hidden"), __always_inline__))
>void
>list<_Tp, _Alloc>::merge(list& __c)
>{
>    merge(__c, __less<value_type>());
>}
>
>template <class _Tp, class _Alloc>
>template <class _Comp>
>void
>list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
>{
>    if (this != &__c)
>    {
>        iterator __f1 = begin();
>        iterator __e1 = end();
>        iterator __f2 = __c.begin();
>        iterator __e2 = __c.end();
>        while (__f1 != __e1 && __f2 != __e2)
>        {
>            if (__comp(*__f2, *__f1))
>            {
>                size_type __ds = 1;
>                iterator __m2 = std::__1::next(__f2);
>                for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds)
>                    ;
>                base::__sz() += __ds;
>                __c.__sz() -= __ds;
>                __node_pointer __f = __f2.__ptr_;
>                __node_pointer __l = __m2.__ptr_->__prev_;
>                __f2 = __m2;
>                base::__unlink_nodes(__f, __l);
>                __m2 = std::__1::next(__f1);
>                __link_nodes(__f1.__ptr_, __f, __l);
>                __f1 = __m2;
>            }
>            else
>                ++__f1;
>        }
>        splice(__e1, __c);
>    }
>}
>
>
>} }
>extern "C" {
> void __assert(const char *, int, const char *);
>#ifdef __i386__
>#define __assert2 __assert_fail
>#endif
> void __assert2(const char *, int, const char *, const char *);
>}
>
>
>extern "C" int printf(const char*, ...);
>using namespace std;
>int main()
>{
>    {
>    int a1[] = {-5, -4, -3, -2, -1, 2, 7, 9, 10};
>    int a2[] = {0, 1, 4, 5, 6, 8, 11, 12, 13};
>    int a3[] = {-5, -4, -3, -2, -1, 0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
>    std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
>    std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
>    std::list<int> c3(a3, a3+sizeof(a3)/sizeof(a3[0]));
>    c1.merge(c2);
>    bool comp = true;
>    for (list<int>::iterator itr = c1.begin(); itr != c1.end(); itr++)
>      printf("c1: %d\n", *itr);
>    for (list<int>::iterator itr = c3.begin(); itr != c3.end(); itr++)
>      printf("c3: %d\n", *itr);
>
>    if (c1.size() != c3.size()) comp = false;
>    if (comp)
>      for (list<int>::iterator itr = c1.begin(), 
>           itr2 = c3.begin(); itr != c1.end(); itr++, itr2++)
>         if (*itr != *itr2) { comp = false; break; }
>
>    if (!comp) { printf ("Not equal !\n"); return 2; }
>
>    return 0;
>    }
>
>}

Actions: View

Attachments on bug 61571: 32979